Merge pull request #3093 from CodaFi/witness-protection-program

[SR-1813] Fix archetype access path binding

Author: rjmccall

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