Merge pull request #4555 from aschwaighofer/swift-3.0-branch-sr1951-fix-2

Swift 3.0 branch SR1951 Fix 2

Author: tkremenek

lib/IRGen/GenArchetype.h

@@ -18,6 +18,7 @@
 #define SWIFT_IRGEN_GENARCHETYPE_H
 
 #include "swift/AST/Types.h"
+#include "llvm/ADT/STLExtras.h"
 
 namespace llvm {
   class Value;
@@ -31,6 +32,13 @@ namespace irgen {
   class Address;
   class IRGenFunction;
 
+  using GetTypeParameterInContextFn =
+    llvm::function_ref<CanType(CanType type)>;
+
+  void bindArchetypeAccessPaths(IRGenFunction &IGF,
+                                GenericSignature *generics,
+                                GetTypeParameterInContextFn getInContext);
+
   /// Emit a type metadata reference for an archetype.
   llvm::Value *emitArchetypeTypeMetadataRef(IRGenFunction &IGF,
                                             CanArchetypeType archetype);

lib/IRGen/GenMeta.cpp

@@ -2762,6 +2762,18 @@ irgen::emitFieldTypeAccessor(IRGenModule &IGM,
   // use it to provide metadata for generic parameters in field types.
   IGF.bindLocalTypeDataFromTypeMetadata(formalType, IsExact, metadata);
 
+  // Bind archetype access paths if the type is generic.
+  if (type->isGenericContext()) {
+    auto declCtxt = type;
+    if (auto generics = declCtxt->getGenericSignatureOfContext()) {
+      auto getInContext = [&](CanType type) -> CanType {
+        return ArchetypeBuilder::mapTypeIntoContext(declCtxt, type, nullptr)
+            ->getCanonicalType();
+      };
+      bindArchetypeAccessPaths(IGF, generics, getInContext);
+    }
+  }
+
   // Allocate storage for the field vector.
   unsigned allocSize = fieldTypes.size() * IGM.getPointerSize().getValue();
   auto allocSizeVal = llvm::ConstantInt::get(IGM.IntPtrTy, allocSize);

lib/IRGen/GenProto.cpp

@@ -1276,6 +1276,17 @@ class AccessorConformanceInfo : public ConformanceInfo {
       }
       return *Fulfillments;
     }
+
+    void bindArchetypeAccessPathsInConformance(IRGenFunction &IGF) {
+      auto declCtx = Conformance.getDeclContext();
+      if (auto generics = declCtx->getGenericSignatureOfContext()) {
+        auto getInContext = [&](CanType type) -> CanType {
+          return ArchetypeBuilder::mapTypeIntoContext(declCtx, type, nullptr)
+              ->getCanonicalType();
+        };
+        bindArchetypeAccessPaths(IGF, generics, getInContext);
+      }
+    }
   };
 }
 
@@ -1335,6 +1346,9 @@ getAssociatedTypeMetadataAccessFunction(AssociatedTypeDecl *requirement,
   // Bind local type data from the metadata argument.
   IGF.bindLocalTypeDataFromTypeMetadata(ConcreteType, IsExact, self);
 
+  // Bind archetype access paths.
+  bindArchetypeAccessPathsInConformance(IGF);
+
   // For now, assume that an associated type is cheap enough to access
   // that it doesn't need a new cache entry.
   if (auto archetype = dyn_cast<ArchetypeType>(associatedType)) {
@@ -1458,6 +1472,9 @@ getAssociatedTypeWitnessTableAccessFunction(AssociatedTypeDecl *requirement,
                                         associatedTypeMetadata);
   IGF.bindLocalTypeDataFromTypeMetadata(ConcreteType, IsExact, self);
 
+  // Bind archetype access paths.
+  bindArchetypeAccessPathsInConformance(IGF);
+
   // For now, assume that finding an abstract conformance is always
   // fast enough that it's not worth caching.
   // TODO: provide an API to find the best metadata path to the conformance
@@ -1832,9 +1849,8 @@ void addPotentialArchetypeAccessPath(IRGenFunction &IGF,
                              {srcBaseArchetype, association});
 }
 
-static void bindArchetypeAccessPaths(IRGenFunction &IGF,
-                                     GenericSignature *Generics,
-                                     GetTypeParameterInContextFn getInContext) {
+void irgen::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()) {

test/IRGen/same_type_constraints.swift

@@ -22,3 +22,23 @@ 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
+
+public protocol MyHashable {}
+public protocol DataType : MyHashable {}
+
+public protocol E {
+  associatedtype Data: DataType
+}
+
+struct Dict<V : MyHashable, K> {}
+struct Val {}
+
+public class GenericKlazz<T: DataType, R: E> : E where R.Data == T
+{
+  public typealias Data = T
+
+  var d: Dict<T, Val>
+  init() {
+     d = Dict()
+  }
+}