Fix archetype access path binding

When considering a type that declares an archetype bound to an
associated type, we were not generating the access paths to any
underlying conformance data and so were not properly able to grab the
witness table for those conformances resulting in a crash.  This way,
all bound requirements also make sure to bind archetype access paths so
we can see actually see the conformances.

Author: CodaFi

lib/IRGen/GenProto.cpp

@@ -1669,32 +1669,39 @@ bool irgen::hasPolymorphicParameters(CanSILFunctionType ty) {
   }
 }
 
-/// Emit a polymorphic parameters clause, binding all the metadata necessary.
-void EmitPolymorphicParameters::emit(Explosion &in,
-                                     WitnessMetadata *witnessMetadata,
-                                     const GetParameterFn &getParameter) {
-  // Collect any early sources and bind local type data from them.
-  for (const Source &source : getSources()) {
-    bindExtraSource(source, in, witnessMetadata);
-  }
+static
+void addPotentialArchetypeAccessPath(IRGenFunction &IGF,
+                                     CanType targetDepType,
+                                     CanType sourceDepType,
+                                     GetTypeParameterInContextFn getInContext) {
+  assert(targetDepType->isTypeParameter());
+  assert(sourceDepType->isTypeParameter());
 
-  // Collect any concrete type metadata that's been passed separately.
-  enumerateUnfulfilledRequirements([&](GenericRequirement requirement) {
-    auto value = in.claimNext();
-    bindGenericRequirement(IGF, requirement, value,
-                           [&](CanType type) { return getTypeInContext(type);});
-  });
+  // We can only break down an associated-type path.
+  auto sourceDepMemberType = dyn_cast<DependentMemberType>(sourceDepType);
+  if (!sourceDepMemberType) return;
 
-  // Bind all the fulfillments we can from the formal parameters.
-  bindParameterSources(getParameter);
+  // We only really need to do this when there's a non-trivial set of
+  // conformances, but we can't determine that just from this decl:
+  // the associated type might gain conformances in a refining protocol.
+  auto association = sourceDepMemberType->getAssocType();
 
-  // Bind all the archetype access paths.
-  bindArchetypeAccessPaths();
-}
+  // These can end up as non-archetypes because of multiple levels of
+  // equality.
+  auto destArchetype =
+    dyn_cast<ArchetypeType>(getInContext(targetDepType));
+  if (!destArchetype) return;
+  auto srcBaseArchetype =
+    dyn_cast<ArchetypeType>(getInContext(sourceDepMemberType.getBase()));
+  if (!srcBaseArchetype) return;
 
-void EmitPolymorphicParameters::bindArchetypeAccessPaths() {
-  if (!Generics) return;
+  IGF.addArchetypeAccessPath(destArchetype,
+                             {srcBaseArchetype, association});
+}
 
+static void bindArchetypeAccessPaths(IRGenFunction &IGF,
+                                     GenericSignature *Generics,
+                                     GetTypeParameterInContextFn getInContext) {
   // Remember all the extra ways we have of reaching the parameter
   // archetypes due to type equality constraints.
   for (auto reqt : Generics->getRequirements()) {
@@ -1710,36 +1717,37 @@ void EmitPolymorphicParameters::bindArchetypeAccessPaths() {
     auto firstType = reqt.getFirstType()->getCanonicalType();
     auto secondType = reqt.getSecondType()->getCanonicalType();
 
-    addPotentialArchetypeAccessPath(firstType, secondType);
-    addPotentialArchetypeAccessPath(secondType, firstType);
+    addPotentialArchetypeAccessPath(IGF, firstType, secondType, getInContext);
+    addPotentialArchetypeAccessPath(IGF, secondType, firstType, getInContext);
   }
 }
 
-void EmitPolymorphicParameters::
-addPotentialArchetypeAccessPath(CanType targetDepType, CanType sourceDepType) {
-  assert(targetDepType->isTypeParameter());
-  assert(sourceDepType->isTypeParameter());
-
-  // We can only break down an associated-type path.
-  auto sourceDepMemberType = dyn_cast<DependentMemberType>(sourceDepType);
-  if (!sourceDepMemberType) return;
+/// Emit a polymorphic parameters clause, binding all the metadata necessary.
+void EmitPolymorphicParameters::emit(Explosion &in,
+                                     WitnessMetadata *witnessMetadata,
+                                     const GetParameterFn &getParameter) {
+  // Collect any early sources and bind local type data from them.
+  for (const Source &source : getSources()) {
+    bindExtraSource(source, in, witnessMetadata);
+  }
+  
+  auto getInContext = [&](CanType type) -> CanType {
+    return getTypeInContext(type);
+  };
 
-  // We only really need to do this when there's a non-trivial set of
-  // conformances, but we can't determine that just from this decl:
-  // the associated type might gain conformances in a refining protocol.
-  auto association = sourceDepMemberType->getAssocType();
+  // Collect any concrete type metadata that's been passed separately.
+  enumerateUnfulfilledRequirements([&](GenericRequirement requirement) {
+    auto value = in.claimNext();
+    bindGenericRequirement(IGF, requirement, value, getInContext);
+  });
 
-  // These can end up as non-archetypes because of multiple levels of
-  // equality.
-  auto destArchetype =
-    dyn_cast<ArchetypeType>(getTypeInContext(targetDepType));
-  if (!destArchetype) return;
-  auto srcBaseArchetype =
-    dyn_cast<ArchetypeType>(getTypeInContext(sourceDepMemberType.getBase()));
-  if (!srcBaseArchetype) return;
+  // Bind all the fulfillments we can from the formal parameters.
+  bindParameterSources(getParameter);
 
-  IGF.addArchetypeAccessPath(destArchetype,
-                             {srcBaseArchetype, association});
+  if (!Generics) return;
+  
+  // Bind all the archetype access paths.
+  bindArchetypeAccessPaths(IGF, Generics, getInContext);
 }
 
 void IRGenFunction::addArchetypeAccessPath(CanArchetypeType targetArchetype,
@@ -2507,6 +2515,12 @@ void GenericTypeRequirements::bindFromBuffer(IRGenFunction &IGF,
                                              Address buffer,
                                     GetTypeParameterInContextFn getInContext) {
   bindFromGenericRequirementsBuffer(IGF, Requirements, buffer, getInContext);
+
+  auto Generics = TheDecl->getGenericSignature();
+  if (!Generics) return;
+
+  // Bind all the archetype access paths in the signature's requirements.
+  bindArchetypeAccessPaths(IGF, Generics, getInContext);
 }
 
 void irgen::bindFromGenericRequirementsBuffer(IRGenFunction &IGF,

lib/IRGen/GenProto.h

@@ -331,10 +331,6 @@ namespace irgen {
     // Did the convention decide that the parameter at the given index
     // was a class-pointer source?
     bool isClassPointerSource(unsigned paramIndex);
-    
-    void bindArchetypeAccessPaths();
-    void addPotentialArchetypeAccessPath(CanType targetDepType,
-                                         CanType sourceDepType);
   };
 
 } // end namespace irgen

test/IRGen/same_type_constraints.swift

@@ -16,3 +16,9 @@ public extension P where Foo == DefaultFoo<Self> {
 }
 
 // CHECK: define{{( protected)?}} void @_TFe21same_type_constraintsRxS_1Pwx3FoozGVS_10DefaultFoox_rS0_3foofT_GS2_x_
+
+// <rdar://26873036> IRGen crash with derived class declaring same-type constraint on constrained associatedtype.
+public class C1<T: Equatable> { }
+public class C2<T: Equatable, U: P where T == U.Foo>: C1<T> {}
+
+// CHECK: define{{( protected)?}} void @_TFC21same_type_constraints2C1D