Sema: Hacky fix for a crash in CSDiag

It looks like the mapTypeIntoContext() call is using the wrong
'dc', because in fact we have no way of knowing what the original
'dc' was which produced the type parameters in question.

Really the problem is we're picking apart SubstitutedType here,
which is almost always the wrong thing to do. I don't think
SubstitutedType should exist at all.

To avoid the crash, just bail-out if 'dc' is not generic.

I'm intentionally avoiding a principled fix here to hasten the
apocalypse when all of CSDiag.cpp will collapse under its own
weight and get rewritten in a sane way.

Author: slavapestov

Diff for: lib/Sema/CSDiag.cpp

@@ -1043,7 +1043,7 @@ static bool findGenericSubstitutions(DeclContext *dc, Type paramType,
 
     bool mismatch(SubstitutableType *paramType, TypeBase *argType) {
       Type type = paramType;
-      if (dc && type->isTypeParameter())
+      if (dc && dc->getGenericParamsOfContext() && type->isTypeParameter())
         type = ArchetypeBuilder::mapTypeIntoContext(dc, paramType);
 
       if (auto archetype = type->getAs<ArchetypeType>()) {
@@ -1062,7 +1062,7 @@ static bool findGenericSubstitutions(DeclContext *dc, Type paramType,
   paramType.findIf([&](Type type) -> bool {
     if (auto substitution = dyn_cast<SubstitutedType>(type.getPointer())) {
       Type original = substitution->getOriginal();
-      if (dc && original->isTypeParameter())
+      if (dc && dc->getGenericParamsOfContext() && original->isTypeParameter())
         original = ArchetypeBuilder::mapTypeIntoContext(dc, original);
 
       Type replacement = substitution->getReplacementType();

Diff for: test/Generics/invalid.swift

@@ -1,4 +1,4 @@
-// RUN: %target-parse-verify-swift
+// RUN: %target-parse-verify-swift -enable-experimental-nested-generic-types
 
 func bet() where A : B {} // expected-error {{'where' clause cannot be attached to a non-generic declaration}}
 
@@ -11,3 +11,63 @@ protocol he where A : B { // expected-error {{'where' clause cannot be attached
 
   associatedtype vav where A : B // expected-error {{'where' clause cannot be attached to an associated type declaration}}
 }
+
+
+struct Lunch<T> {
+  struct Dinner<U> {
+
+    var leftovers: T
+    var transformation: (T) -> U
+  }
+}
+
+class Deli<Spices> {
+
+  class Pepperoni {}
+  struct Sausage {}
+}
+
+struct Pizzas<Spices> {
+  class NewYork {
+  }
+
+  class DeepDish {
+  }
+}
+
+class HotDog {
+}
+
+struct Pepper {}
+struct ChiliFlakes {}
+
+func eatDinnerConcrete(d: Pizzas<ChiliFlakes>.NewYork,
+                       t: Deli<ChiliFlakes>.Pepperoni) {
+}
+
+func eatDinnerConcrete(d: Pizzas<Pepper>.DeepDish,
+                       t: Deli<Pepper>.Pepperoni) {
+}
+
+func badDiagnostic1() {
+
+  _ = Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDog>( // expected-error {{expression type 'Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDog>' is ambiguous without more context}}
+      leftovers: Pizzas<ChiliFlakes>.NewYork(),
+      transformation: { _ in HotDog() })
+}
+
+func badDiagnostic2() {
+
+  let firstCourse = Pizzas<ChiliFlakes>.NewYork()
+
+  var dinner = Lunch<Pizzas<ChiliFlakes>.NewYork>.Dinner<HotDog>(
+      leftovers: firstCourse,
+      transformation: { _ in HotDog() })
+
+  let topping = Deli<Pepper>.Pepperoni()
+
+  eatDinnerConcrete(d: firstCourse, t: topping)
+  // expected-error@-1 {{cannot invoke 'eatDinnerConcrete' with an argument list of type '(d: Pizzas<ChiliFlakes>.NewYork, t: Deli<Pepper>.Pepperoni)'}}
+  // expected-note@-2 {{overloads for 'eatDinnerConcrete' exist with these partially matching parameter lists: (d: Pizzas<ChiliFlakes>.NewYork, t: Deli<ChiliFlakes>.Pepperoni), (d: Pizzas<Pepper>.DeepDish, t: Deli<Pepper>.Pepperoni)}}
+
+}