Reimplement NormalProtocolConformance::getAssocated{Type|Conformance}.

Reimplement these methods, making use of Type::subst() for
the former and the stored protocol conformances that correspond to the
protocol's requirement signature for the latter. This is enough to
emit witness tables with indirect conformance requirements in them.

Author: DougGregor

lib/AST/ProtocolConformance.cpp

@@ -336,50 +336,35 @@ void NormalProtocolConformance::setTypeWitness(
   TypeWitnesses[assocType] = std::make_pair(substitution, typeDecl);
 }
 
-/// TypeWitnesses is keyed by the protocol's own declarations, but
-/// DependentMemberTypes will sometimes store a base protocol's declaration.
-/// Map to the derived declaration if possible.
-static AssociatedTypeDecl *getOwnAssociatedTypeDecl(ProtocolDecl *protocol,
-                                                    AssociatedTypeDecl *assoc) {
-  // Fast path.
-  if (assoc->getProtocol() == protocol) return assoc;
-
-  // Search the protocol.
-  for (auto member : protocol->getMembers()) {
-    if (auto memberAssoc = dyn_cast<AssociatedTypeDecl>(member)) {
-      if (memberAssoc->getName() == assoc->getName()) {
-        return memberAssoc;
-      }
-    }
-  }
-
-  // Just assume this is fine.
-  return assoc;
-}
-
 Type NormalProtocolConformance::getAssociatedType(Type assocType,
                                                 LazyResolver *resolver) const {
   assert(assocType->isTypeParameter() &&
          "associated type must be a type parameter");
 
-  // Fast path.
   auto type = assocType->getCanonicalType();
+  auto proto = getProtocol();
+
+#if false
+  // Fast path for generic parameters.
   if (isa<GenericTypeParamType>(type)) {
-    assert(type->isEqual(getProtocol()->getSelfInterfaceType()) &&
+    assert(type->isEqual(proto->getSelfInterfaceType()) &&
            "type parameter in protocol was not Self");
     return getType();
   }
 
+  // Fast path for dependent member types on 'Self' of our associated types.
   auto memberType = cast<DependentMemberType>(type);
+  if (memberType.getBase()->isEqual(proto->getProtocolSelfType()) &&
+      memberType->getAssocType()->getProtocol() == proto)
+    return getTypeWitness(memberType->getAssocType(), nullptr).getReplacement();
+#endif
 
-  // TODO: make this handle multiple levels of dependent member type.
-  assert(memberType.getBase()->isEqual(getProtocol()->getSelfInterfaceType()) &&
-         "dependent member in protocol was not rooted in Self");
-
-  auto assocTypeDecl =
-    getOwnAssociatedTypeDecl(getProtocol(), memberType->getAssocType());
-  auto &subst = getTypeWitnessSubstAndDecl(assocTypeDecl, resolver).first;
-  return subst.getReplacement();
+  // General case: consult the substitution map.
+  auto self = const_cast<NormalProtocolConformance *>(this);
+  auto substMap =
+    SubstitutionMap::getProtocolSubstitutions(proto, getType(),
+                                              ProtocolConformanceRef(self));
+  return type.subst(substMap);
 }
 
 ProtocolConformanceRef
@@ -389,48 +374,21 @@ NormalProtocolConformance::getAssociatedConformance(Type assocType,
   assert(assocType->isTypeParameter() &&
          "associated type must be a type parameter");
 
-#ifndef NDEBUG
-  bool foundInRequirements = false;
+  unsigned conformanceIndex = 0;
   for (auto &reqt :
          getProtocol()->getRequirementSignature()->getRequirements()) {
-    if (reqt.getKind() == RequirementKind::Conformance &&
-        reqt.getFirstType()->isEqual(assocType) &&
-        reqt.getSecondType()->castTo<ProtocolType>()->getDecl() == protocol) {
-      foundInRequirements = true;
-      break;
-    }
-  }
-  assert(foundInRequirements &&
-         "requested conformance was not a direct requirement of the protocol");
-#endif
-
-  auto type = assocType->getCanonicalType();
+    if (reqt.getKind() == RequirementKind::Conformance) {
+      // Is this the conformance we're looking for?
+      if (reqt.getFirstType()->isEqual(assocType) &&
+          reqt.getSecondType()->castTo<ProtocolType>()->getDecl() == protocol)
+        return getSignatureConformances()[conformanceIndex];
 
-  if (isa<GenericTypeParamType>(type)) {
-    assert(type->isEqual(getProtocol()->getSelfInterfaceType()) &&
-           "type parameter in protocol was not Self");
-    auto conf = getInheritedConformance(protocol);
-    assert(conf && "inherited conformances cannot be abstract");
-    return ProtocolConformanceRef(conf);
+      ++conformanceIndex;
+    }
   }
 
-  auto memberType = cast<DependentMemberType>(type);
-
-  // For now, NormalProtocolConformance does not store indirect associations.
-  assert(memberType.getBase()->isEqual(getProtocol()->getSelfInterfaceType()) &&
-         "dependent member in protocol was not rooted in Self");
-
-  auto assocTypeDecl =
-    getOwnAssociatedTypeDecl(getProtocol(), memberType->getAssocType());
-  auto &subst = getTypeWitnessSubstAndDecl(assocTypeDecl, resolver).first;
-
-  // Scan the conformances for the exact conformance.
-  // TODO: should we allow indirect conformances for convenience of use?
-  for (auto &conf : subst.getConformances()) {
-    if (conf.getRequirement() == protocol)
-      return conf;
-  }
-  llvm_unreachable("missing conformance to protocol");
+  llvm_unreachable(
+    "requested conformance was not a direct requirement of the protocol");
 }
 
   /// Retrieve the value witness corresponding to the given requirement.

test/IRGen/witness_table_indirect_conformances.swift

@@ -0,0 +1,50 @@
+// RUN: %target-swift-frontend -Xllvm -new-mangling-for-tests -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir -disable-objc-attr-requires-foundation-module -swift-version 4 | %FileCheck %s
+
+protocol P1 {
+	associatedtype AssocP1
+}
+
+protocol P2 {
+	associatedtype AssocP2: P1
+
+	func getAssocP2() -> AssocP2
+}
+
+protocol P3 {
+	associatedtype AssocP3: P2 where AssocP3.AssocP2: Q
+
+	func getAssocP3() -> AssocP3
+}
+
+protocol Q { }
+
+struct X { }
+
+struct Y: P1, Q {
+	typealias AssocP1 = X
+}
+
+struct Z: P2 {
+	typealias AssocP2 = Y
+
+	func getAssocP2() -> Y { return Y() }
+}
+
+// CHECK: @_T035witness_table_indirect_conformances1WVAA2P3AAWP = hidden constant [4 x i8*] [i8* bitcast (%swift.type* ()* @_T035witness_table_indirect_conformances1ZVMa to i8*), i8* bitcast (i8** ()* @_T035witness_table_indirect_conformances1ZVAA2P2AAWa to i8*), i8* bitcast (i8** ()* @_T035witness_table_indirect_conformances1YVAA1QAAWa to i8*), i8* bitcast (void (%T35witness_table_indirect_conformances1ZV*, %T35witness_table_indirect_conformances1WV*, %swift.type*, i8**)* @_T035witness_table_indirect_conformances1WVAA2P3A2aDP08getAssocE00gE0QzyFTW to i8*)]
+struct W: P3 {
+	typealias AssocP3 = Z
+
+	func getAssocP3() -> Z { return Z() }
+}
+
+// CHECK-LABEL: define hidden i8** @_T035witness_table_indirect_conformances1YVAA1QAAWa()
+// CHECK-NEXT: entry:
+// CHECK-NEXT: ret i8** getelementptr inbounds ([0 x i8*], [0 x i8*]* @_T035witness_table_indirect_conformances1YVAA1QAAWP, i32 0, i32 0)
+
+// CHECK-LABEL: define hidden i8** @_T035witness_table_indirect_conformances1ZVAA2P2AAWa()
+// CHECK-NEXT: entry:
+// CHECK: ret i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @_T035witness_table_indirect_conformances1ZVAA2P2AAWP, i32 0, i32 0)
+
+// CHECK-LABEL: define hidden %swift.type* @_T035witness_table_indirect_conformances1ZVMa()
+// CHECK-NEXT: entry:
+// CHECK-NEXT: ret %swift.type* bitcast {{.*}} @_T035witness_table_indirect_conformances1ZVMf, i32 0, i32 1) to %swift.type*