[Archetype builder] Check concrete types against superclass constraints.

This was a blatant hole in our checking, admitting ill-formed generic
signatures that would crash down the line. Fixes
rdar://problem/29288428.

Author: DougGregor

lib/AST/ArchetypeBuilder.cpp

@@ -988,6 +988,21 @@ bool ArchetypeBuilder::addSuperclassRequirement(PotentialArchetype *T,
         });
   }
 
+  // Make sure the concrete type fulfills the superclass requirement
+  // of the archetype.
+  if (T->isConcreteType()) {
+    Type concrete = T->getConcreteType();
+    if (!Superclass->isExactSuperclassOf(concrete, getLazyResolver())) {
+      Diags.diagnose(T->getSameTypeSource().getLoc(),
+                     diag::type_does_not_inherit,
+                     T->getRootParam(), concrete, Superclass)
+        .highlight(Source.getLoc());
+      return true;
+    }
+
+    return false;
+  }
+
   // Local function to handle the update of superclass conformances
   // when the superclass constraint changes.
   auto updateSuperclassConformances = [&] {
@@ -1273,6 +1288,17 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
   T->ArchetypeOrConcreteType = NestedType::forConcreteType(Concrete);
   T->SameTypeSource = Source;
 
+  // Make sure the concrete type fulfills the superclass requirement
+  // of the archetype.
+  if (T->Superclass) {
+    if (!T->Superclass->isExactSuperclassOf(Concrete, getLazyResolver())) {
+      Diags.diagnose(Source.getLoc(), diag::type_does_not_inherit,
+                     T->getRootParam(), Concrete, T->Superclass)
+        .highlight(T->SuperclassSource->getLoc());
+      return true;
+    }
+  }
+
   // Recursively resolve the associated types to their concrete types.
   RequirementSource nestedSource(RequirementSource::Redundant, Source.getLoc());
   for (auto nested : T->getNestedTypes()) {

test/Generics/same_type_constraints.swift

@@ -318,3 +318,18 @@ struct EventHorizon : Timewarp {
 func activate<T>(_ t: T) {}
 
 activate(Teleporter<EventHorizon, Beam>())
+
+// rdar://problem/29288428
+class C {}
+
+protocol P9 {
+  associatedtype A
+}
+
+struct X7<T: P9> where T.A : C { }
+
+extension X7 where T.A == Int { } // expected-error 2{{'T' requires that 'Int' inherit from 'C'}}
+
+struct X8<T: C> { }
+
+extension X8 where T == Int { } // expected-error 2{{'T' requires that 'Int' inherit from 'C'}}