Use conformance access paths in IRGen

include/swift/AST/ProtocolConformance.h

@@ -229,6 +229,18 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
   /// Retrieve the complete set of protocol conformances for directly inherited
   /// protocols.
   const InheritedConformanceMap &getInheritedConformances() const;
+
+  /// Given a dependent type expressed in terms of the self parameter,
+  /// map it into the context of this conformance.
+  Type getAssociatedType(Type assocType,
+                         LazyResolver *resolver = nullptr) const;
+
+  /// Given that the requirement signature of the protocol directly states
+  /// that the given dependent type must conform to the given protocol,
+  /// return its associated conformance.
+  ProtocolConformanceRef
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
+                           LazyResolver *resolver = nullptr) const;
 
   /// Get the generic parameters open on the conforming type.
   GenericEnvironment *getGenericEnvironment() const;
@@ -441,11 +453,6 @@ class NormalProtocolConformance : public ProtocolConformance,
                       const Substitution &substitution,
                       TypeDecl *typeDecl) const;
 
-  /// Given a dependent type expressed in terms of the self parameter,
-  /// map it into the context of this conformance.
-  Type getAssociatedType(Type assocType,
-                         LazyResolver *resolver = nullptr) const;
-
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.
@@ -611,6 +618,13 @@ class SpecializedProtocolConformance : public ProtocolConformance,
     return GenericConformance->getInheritedConformances();
   }
 
+  /// Given that the requirement signature of the protocol directly states
+  /// that the given dependent type must conform to the given protocol,
+  /// return its associated conformance.
+  ProtocolConformanceRef
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
+                           LazyResolver *resolver = nullptr) const;
+
   /// Determine whether the witness for the given requirement
   /// is either the default definition or was otherwise deduced.
   bool usesDefaultDefinition(AssociatedTypeDecl *requirement) const {
@@ -709,6 +723,13 @@ class InheritedProtocolConformance : public ProtocolConformance,
     return InheritedConformance->getWitness(requirement, resolver);
   }
 
+  /// Given that the requirement signature of the protocol directly states
+  /// that the given dependent type must conform to the given protocol,
+  /// return its associated conformance.
+  ProtocolConformanceRef
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
+                           LazyResolver *resolver = nullptr) const;
+
   /// Retrieve the protocol conformances directly-inherited protocols.
   const InheritedConformanceMap &getInheritedConformances() const {
     return InheritedConformance->getInheritedConformances();

include/swift/AST/ProtocolConformanceRef.h

@@ -96,6 +96,18 @@ class ProtocolConformanceRef {
                                TypeSubstitutionFn subs,
                                LookupConformanceFn conformances) const;
 
+  /// Given a dependent type (expressed in terms of this conformance's
+  /// protocol), follow it from the conforming type.
+  Type getAssociatedType(Type origType, Type dependentType,
+                         LazyResolver *resolver = nullptr) const;
+
+  /// Given a dependent type (expressed in terms of this conformance's
+  /// protocol) and conformance, follow it from the conforming type.
+  ProtocolConformanceRef
+  getAssociatedConformance(Type origType, Type dependentType,
+                           ProtocolDecl *requirement,
+                           LazyResolver *resolver = nullptr) const;
+
   void dump() const;
   void dump(llvm::raw_ostream &out, unsigned indent = 0) const;
 

lib/AST/ASTDumper.cpp

@@ -2611,6 +2611,7 @@ void ProtocolConformanceRef::dump(llvm::raw_ostream &out,
     out.indent(indent) << "(abstract_conformance protocol="
                        << getAbstract()->getName();
     PrintWithColorRAII(out, ParenthesisColor) << ')';
+    out << '\n';
   }
 }
 

lib/AST/ProtocolConformance.cpp

@@ -397,13 +397,22 @@ void NormalProtocolConformance::setTypeWitness(
   TypeWitnesses[assocType] = std::make_pair(substitution, typeDecl);
 }
 
-Type NormalProtocolConformance::getAssociatedType(Type assocType,
-                                                LazyResolver *resolver) const {
+Type ProtocolConformance::getAssociatedType(Type assocType,
+                                            LazyResolver *resolver) const {
   assert(assocType->isTypeParameter() &&
          "associated type must be a type parameter");
 
+  ProtocolConformanceRef ref(const_cast<ProtocolConformance*>(this));
+  return ref.getAssociatedType(getType(), assocType, resolver);
+}
+
+Type ProtocolConformanceRef::getAssociatedType(Type conformingType,
+                                               Type assocType,
+                                               LazyResolver *resolver) const {
+  assert(!isConcrete() || getConcrete()->getType()->isEqual(conformingType));
+
   auto type = assocType->getCanonicalType();
-  auto proto = getProtocol();
+  auto proto = getRequirement();
 
 #if false
   // Fast path for generic parameters.
@@ -421,13 +430,43 @@ Type NormalProtocolConformance::getAssociatedType(Type assocType,
 #endif
 
   // General case: consult the substitution map.
-  auto self = const_cast<NormalProtocolConformance *>(this);
   auto substMap =
-    SubstitutionMap::getProtocolSubstitutions(proto, getType(),
-                                              ProtocolConformanceRef(self));
+    SubstitutionMap::getProtocolSubstitutions(proto, conformingType, *this);
   return type.subst(substMap);
 }
 
+ProtocolConformanceRef
+ProtocolConformanceRef::getAssociatedConformance(Type conformingType,
+                                                 Type assocType,
+                                                 ProtocolDecl *protocol,
+                                                 LazyResolver *resolver) const {
+  // If this is a concrete conformance, look up the associated conformance.
+  if (isConcrete()) {
+    auto conformance = getConcrete();
+    assert(conformance->getType()->isEqual(conformingType));
+    return conformance->getAssociatedConformance(assocType, protocol, resolver);
+  }
+
+  // Otherwise, apply the substitution {self -> conformingType}
+  // to the abstract conformance requirement laid upon the dependent type
+  // by the protocol.
+  auto subMap =
+    SubstitutionMap::getProtocolSubstitutions(getRequirement(),
+                                              conformingType, *this);
+  auto abstractConf = ProtocolConformanceRef(protocol);
+  return abstractConf.subst(assocType,
+                            QuerySubstitutionMap{subMap},
+                            LookUpConformanceInSubstitutionMap(subMap));
+}
+
+ProtocolConformanceRef
+ProtocolConformance::getAssociatedConformance(Type assocType,
+                                               ProtocolDecl *protocol,
+                                               LazyResolver *resolver) const {
+  CONFORMANCE_SUBCLASS_DISPATCH(getAssociatedConformance,
+                                (assocType, protocol, resolver))
+}
+
 ProtocolConformanceRef
 NormalProtocolConformance::getAssociatedConformance(Type assocType,
                                                     ProtocolDecl *protocol,
@@ -582,6 +621,35 @@ SpecializedProtocolConformance::getWitness(ValueDecl *requirement,
   return GenericConformance->getWitness(requirement, resolver);
 }
 
+ProtocolConformanceRef
+SpecializedProtocolConformance::getAssociatedConformance(Type assocType,
+                                                ProtocolDecl *protocol,
+                                                LazyResolver *resolver) const {
+  ProtocolConformanceRef conformance =
+    GenericConformance->getAssociatedConformance(assocType, protocol, resolver);
+
+  auto genericEnv = GenericConformance->getGenericEnvironment();
+  auto subMap = genericEnv->getSubstitutionMap(GenericSubstitutions);
+
+  Type origType =
+    (conformance.isConcrete()
+       ? conformance.getConcrete()->getType()
+       : GenericConformance->getAssociatedType(assocType, resolver));
+
+  return conformance.subst(origType,
+                           QuerySubstitutionMap{subMap},
+                           LookUpConformanceInSubstitutionMap(subMap));
+}
+
+ProtocolConformanceRef
+InheritedProtocolConformance::getAssociatedConformance(Type assocType,
+                         ProtocolDecl *protocol,
+                         LazyResolver *resolver) const {
+  // FIXME: Substitute!
+  return InheritedConformance->getAssociatedConformance(assocType, protocol,
+                                                        resolver);
+}
+
 const NormalProtocolConformance *
 ProtocolConformance::getRootNormalConformance() const {
   const ProtocolConformance *C = this;

lib/IRGen/Fulfillment.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/TypeLowering.h"
 #include "GenericRequirement.h"
+#include "ProtocolInfo.h"
 
 using namespace swift;
 using namespace irgen;
@@ -179,22 +180,20 @@ bool FulfillmentMap::searchWitnessTable(IRGenModule &IGM,
 
   bool hadFulfillment = false;
 
-  auto nextInheritedIndex = 0;
-  for (auto inherited : protocol->getInheritedProtocols()) {
-    auto index = nextInheritedIndex++;
+  auto &pi = IGM.getProtocolInfo(protocol);
 
-    // Ignore protocols that don't have witness tables.
-    if (!Lowering::TypeConverter::protocolRequiresWitnessTable(inherited))
-      continue;
+  for (auto &entry : pi.getWitnessEntries()) {
+    if (!entry.isBase()) continue;
 
+    ProtocolDecl *inherited = entry.getBase();
     MetadataPath inheritedPath = path;
-    inheritedPath.addInheritedProtocolComponent(index);
+    inheritedPath.addInheritedProtocolComponent(pi.getBaseWitnessIndex(&entry));
     hadFulfillment |= searchWitnessTable(IGM, type, inherited,
                                          source, std::move(inheritedPath),
                                          keys, interestingConformances);
   }
 
-  // If we're not limited the set of interesting conformances, or if
+  // If we're not limiting the set of interesting conformances, or if
   // this is an interesting conformance, record it.
   if (!interestingConformances || interestingConformances->count(protocol)) {
     hadFulfillment |= addFulfillment({type, protocol}, source, std::move(path));