AST: Re-implement associated conformance storage in preparation for AssociatedConformanceRequest

Author: slavapestov

include/swift/AST/ProtocolConformance.h

@@ -480,7 +480,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   /// Conformances that satisfy each of conformance requirements of the
   /// requirement signature of the protocol.
-  ArrayRef<ProtocolConformanceRef> SignatureConformances;
   MutableArrayRef<llvm::Optional<ProtocolConformanceRef>> AssociatedConformances;
 
   /// The lazy member loader provides callbacks for populating imported and
@@ -545,7 +544,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// Mark this conformance as invalid.
   void setInvalid() {
     ContextAndBits.setInt(ContextAndBits.getInt() | InvalidFlag);
-    SignatureConformances = {};
   }
 
   /// Whether this is an "unchecked" conformance.
@@ -666,19 +664,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// Override the witness for a given requirement.
   void overrideWitness(ValueDecl *requirement, Witness newWitness);
 
-  /// Retrieve the protocol conformances that satisfy the requirements of the
-  /// protocol, which line up with the conformance constraints in the
-  /// protocol's requirement signature.
-  ArrayRef<ProtocolConformanceRef> getSignatureConformances() const {
-    if (Loader)
-      resolveLazyInfo();
-    return SignatureConformances;
-  }
-
-  /// Copy the given protocol conformances for the requirement signature into
-  /// the normal conformance.
-  void setSignatureConformances(ArrayRef<ProtocolConformanceRef> conformances);
-
   /// Populate the signature conformances without checking if they satisfy
   /// requirements. Can only be used with parsed or imported conformances.
   void finishSignatureConformances();

lib/AST/ProtocolConformance.cpp

@@ -388,34 +388,6 @@ ConditionalRequirementsRequest::evaluate(Evaluator &evaluator,
   return NPC->getProtocol()->getASTContext().AllocateCopy(unsatReqs);
 }
 
-void NormalProtocolConformance::setSignatureConformances(
-                               ArrayRef<ProtocolConformanceRef> conformances) {
-  if (conformances.empty()) {
-    SignatureConformances = { };
-    return;
-  }
-
-  auto &ctx = getProtocol()->getASTContext();
-  SignatureConformances = ctx.AllocateCopy(conformances);
-
-#if !NDEBUG
-  unsigned idx = 0;
-  auto reqs = getProtocol()->getRequirementSignature().getRequirements();
-  for (const auto &req : reqs) {
-    if (req.getKind() == RequirementKind::Conformance) {
-      assert(!conformances[idx].isConcrete() ||
-             !conformances[idx].getConcrete()->getType()->hasArchetype() &&
-             "Should have interface types here");
-      assert(idx < conformances.size());
-      assert(conformances[idx].isInvalid() ||
-             conformances[idx].getRequirement() == req.getProtocolDecl());
-      ++idx;
-    }
-  }
-  assert(idx == conformances.size() && "Too many conformances");
-#endif
-}
-
 void NormalProtocolConformance::resolveLazyInfo() const {
   assert(Loader);
 
@@ -552,14 +524,12 @@ NormalProtocolConformance::getAssociatedConformance(Type assocType,
       [&](Type t, ProtocolDecl *p, unsigned index) {
         if (t->isEqual(assocType) && p == protocol) {
           // Fill in the signature conformances, if we haven't done so yet.
-          if (getSignatureConformances().empty()) {
-            const_cast<NormalProtocolConformance *>(this)->finishSignatureConformances();
+          if (!hasComputedAssociatedConformances()) {
+            const_cast<NormalProtocolConformance *>(this)
+                ->finishSignatureConformances();
           }
 
-          assert(!getSignatureConformances().empty() &&
-                 "signature conformances not yet computed");
-
-          result = getSignatureConformances()[index];
+          result = getAssociatedConformance(index);
           return true;
         }
 
@@ -639,55 +609,53 @@ recursivelySubstituteBaseType(ModuleDecl *module,
 
 /// Collect conformances for the requirement signature.
 void NormalProtocolConformance::finishSignatureConformances() {
-  if (!SignatureConformances.empty())
-    return;
+  if (Loader)
+    resolveLazyInfo();
 
-  auto *proto = getProtocol();
-  auto reqSig = proto->getRequirementSignature().getRequirements();
-  if (reqSig.empty())
+  if (hasComputedAssociatedConformances())
     return;
 
-  SmallVector<ProtocolConformanceRef, 4> reqConformances;
-  for (const auto &req : reqSig) {
-    if (req.getKind() != RequirementKind::Conformance)
-      continue;
+  createAssociatedConformanceArray();
 
-    ModuleDecl *module = getDeclContext()->getParentModule();
+  auto *proto = getProtocol();
+  ModuleDecl *module = getDeclContext()->getParentModule();
 
-    Type substTy;
-    auto origTy = req.getFirstType();
-    if (origTy->isEqual(proto->getSelfInterfaceType())) {
-      substTy = getType();
-    } else {
-      auto *depMemTy = origTy->castTo<DependentMemberType>();
-      substTy = recursivelySubstituteBaseType(module, this, depMemTy);
-    }
-    auto reqProto = req.getProtocolDecl();
+  forEachAssociatedConformance(
+    [&](Type origTy, ProtocolDecl *reqProto, unsigned index) {
+      Type substTy;
+
+      if (origTy->isEqual(proto->getSelfInterfaceType())) {
+        substTy = getType();
+      } else {
+        auto *depMemTy = origTy->castTo<DependentMemberType>();
+        substTy = recursivelySubstituteBaseType(module, this, depMemTy);
+      }
 
-    // Looking up a conformance for a contextual type and mapping the
-    // conformance context produces a more accurate result than looking
-    // up a conformance from an interface type.
-    //
-    // This can happen if the conformance has an associated conformance
-    // depending on an associated type that is made concrete in a
-    // refining protocol.
-    //
-    // That is, the conformance of an interface type G<T> : P really
-    // depends on the generic signature of the current context, because
-    // performing the lookup in a "more" constrained extension than the
-    // one where the conformance was defined must produce concrete
-    // conformances.
-    //
-    // FIXME: Eliminate this, perhaps by adding a variant of
-    // lookupConformance() taking a generic signature.
-    if (substTy->hasTypeParameter())
-      substTy = getDeclContext()->mapTypeIntoContext(substTy);
-
-    reqConformances.push_back(module->lookupConformance(substTy, reqProto,
-                                                        /*allowMissing=*/true)
-                                  .mapConformanceOutOfContext());
-  }
-  setSignatureConformances(reqConformances);
+      // Looking up a conformance for a contextual type and mapping the
+      // conformance context produces a more accurate result than looking
+      // up a conformance from an interface type.
+      //
+      // This can happen if the conformance has an associated conformance
+      // depending on an associated type that is made concrete in a
+      // refining protocol.
+      //
+      // That is, the conformance of an interface type G<T> : P really
+      // depends on the generic signature of the current context, because
+      // performing the lookup in a "more" constrained extension than the
+      // one where the conformance was defined must produce concrete
+      // conformances.
+      //
+      // FIXME: Eliminate this, perhaps by adding a variant of
+      // lookupConformance() taking a generic signature.
+      if (substTy->hasTypeParameter())
+        substTy = getDeclContext()->mapTypeIntoContext(substTy);
+
+      auto assocConf = module->lookupConformance(substTy, reqProto,
+                                                 /*allowMissing=*/true)
+                                    .mapConformanceOutOfContext();
+      setAssociatedConformance(index, assocConf);
+      return false;
+    });
 }
 
 Witness RootProtocolConformance::getWitness(ValueDecl *requirement) const {

lib/AST/SubstitutionMap.cpp

@@ -433,7 +433,7 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
     auto normal = concrete->getRootNormalConformance();
 
     // If we haven't set the signature conformances yet, force the issue now.
-    if (normal->getSignatureConformances().empty()) {
+    if (!normal->hasComputedAssociatedConformances()) {
       // If we're in the process of checking the type witnesses, fail
       // gracefully.
       // FIXME: Seems like we should be able to get at the intermediate state

lib/Serialization/Deserialization.cpp

@@ -7988,7 +7988,6 @@ void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
           llvm::inconvertibleErrorCode()));
     }
   }
-  conformance->setSignatureConformances(reqConformances);
 
   for (unsigned index : indices(reqConformances)) {
     conformance->setAssociatedConformance(index, reqConformances[index]);