Merge pull request swiftlang#69038 from slavapestov/clean-up-associated-conformances

Preparation for lazily populating associated conformances

Author: slavapestov

include/swift/AST/ProtocolConformance.h

@@ -191,6 +191,27 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
     return false;
   }
 
+  /// Apply the given function object to each associated conformance requirement
+  /// within this protocol conformance.
+  ///
+  /// \returns true if the function ever returned true
+  template<typename F>
+  bool forEachAssociatedConformance(F f) const {
+    const ProtocolDecl *protocol = getProtocol();
+    unsigned index = 0;
+    for (auto req : protocol->getRequirementSignature().getRequirements()) {
+      if (req.getKind() != RequirementKind::Conformance)
+        continue;
+
+      if (f(req.getFirstType(), req.getProtocolDecl(), index))
+        return true;
+
+      ++index;
+    }
+
+    return false;
+  }
+
   /// Retrieve the value witness declaration corresponding to the given
   /// requirement.
   ValueDecl *getWitnessDecl(ValueDecl *requirement) const;
@@ -423,13 +444,18 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
     /// The conformance was labeled with @unchecked.
     UncheckedFlag = 0x02,
+
+    /// We have allocated the AssociatedConformances array (but not necessarily
+    /// populated any of its elements).
+    HasComputedAssociatedConformancesFlag = 0x04,
   };
 
   /// The declaration context containing the ExtensionDecl or
   /// NominalTypeDecl that declared the conformance.
   ///
-  /// Also stores the "invalid" and "unchecked" bits.
-  llvm::PointerIntPair<DeclContext *, 2, unsigned> ContextAndBits;
+  /// Also stores the "invalid", "unchecked" and "has computed associated
+  /// conformances" bits.
+  llvm::PointerIntPair<DeclContext *, 3, unsigned> ContextAndBits;
 
   /// The reason that this conformance exists.
   ///
@@ -454,7 +480,7 @@ 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
   /// deserialized conformances.
@@ -518,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.
@@ -533,6 +558,17 @@ class NormalProtocolConformance : public RootProtocolConformance,
     ContextAndBits.setInt(ContextAndBits.getInt() | UncheckedFlag);
   }
 
+  /// Determine whether we've lazily computed the associated conformance array
+  /// already.
+  bool hasComputedAssociatedConformances() const {
+    return ContextAndBits.getInt() & HasComputedAssociatedConformancesFlag;
+  }
+
+  /// Mark this conformance as having computed the assocaited conformance array.
+  void setHasComputedAssociatedConformances() {
+    ContextAndBits.setInt(ContextAndBits.getInt() | HasComputedAssociatedConformancesFlag);
+  }
+
   /// Get the kind of source from which this conformance comes.
   ConformanceEntryKind getSourceKind() const {
     return SourceKindAndImplyingConformance.getInt();
@@ -599,6 +635,16 @@ class NormalProtocolConformance : public RootProtocolConformance,
   ProtocolConformanceRef
   getAssociatedConformance(Type assocType, ProtocolDecl *protocol) const;
 
+  /// Allocate the backing array if needed, computing its size from the
+  ///protocol's requirement signature.
+  void createAssociatedConformanceArray();
+
+  llvm::Optional<ProtocolConformanceRef>
+  getAssociatedConformance(unsigned index) const;
+
+  void
+  setAssociatedConformance(unsigned index, ProtocolConformanceRef assocConf);
+
   /// Retrieve the value witness corresponding to the given requirement.
   Witness getWitness(ValueDecl *requirement) const;
 
@@ -618,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();

include/swift/AST/TypeCheckRequests.h

@@ -2737,6 +2737,30 @@ class ValueWitnessRequest
   void cacheResult(Witness value) const;
 };
 
+class AssociatedConformanceRequest
+    : public SimpleRequest<AssociatedConformanceRequest,
+                           ProtocolConformanceRef(NormalProtocolConformance *,
+                                                  CanType, ProtocolDecl *,
+                                                  unsigned),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ProtocolConformanceRef
+  evaluate(Evaluator &evaluator, NormalProtocolConformance *conformance,
+           CanType t, ProtocolDecl *proto, unsigned index) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  llvm::Optional<ProtocolConformanceRef> getCachedResult() const;
+  void cacheResult(ProtocolConformanceRef value) const;
+};
+
 struct PreCheckResultBuilderDescriptor {
   AnyFunctionRef Fn;
   bool SuppressDiagnostics;

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -403,6 +403,10 @@ SWIFT_REQUEST(TypeChecker, TypeWitnessRequest,
               TypeWitnessAndDecl(NormalProtocolConformance *,
                                  AssociatedTypeDecl *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, AssociatedConformanceRequest,
+              ProtocolConformanceRef(NormalProtocolConformance *,
+                                     Type, ProtocolDecl *, unsigned),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ValueWitnessRequest,
               Witness(NormalProtocolConformance *, ValueDecl *),
               SeparatelyCached, NoLocationInfo)

lib/AST/ASTDumper.cpp

@@ -3414,7 +3414,8 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
       });
     }
 
-    printRecRange(T->getGenericArguments(), "generic_arguments");
+    for (auto arg : T->getGenericArguments())
+      printRec(arg);
 
     printFoot();
   }
@@ -3549,6 +3550,7 @@ class PrintConformance : public PrintBase {
             });
             return false;
           });
+
           normal->forEachValueWitness([&](const ValueDecl *req,
                                           Witness witness) {
             printRecArbitrary([&](StringRef label) {
@@ -3566,9 +3568,17 @@ class PrintConformance : public PrintBase {
             });
           });
 
-          for (auto sigConf : normal->getSignatureConformances()) {
-            printRec(sigConf, visited);
-          }
+          normal->forEachAssociatedConformance(
+              [&](Type t, ProtocolDecl *proto, unsigned index) {
+                printRecArbitrary([&](StringRef label) {
+                  printHead("assoc_conformance", ASTNodeColor, label);
+                  printFieldQuoted(t, "type", TypeColor);
+                  printFieldQuoted(proto->getName(), "proto");
+                  printRec(normal->getAssociatedConformance(t, proto), visited);
+                  printFoot();
+                });
+                return false;
+              });
         }
 
         if (auto condReqs = normal->getConditionalRequirementsIfAvailable()) {
@@ -3886,14 +3896,16 @@ namespace {
 
       printFieldQuoted(T->getDecl()->printRef(), "decl");
       if (auto underlying = T->getSinglyDesugaredType()) {
-        printField(underlying, "underlying", TypeColor);
+        printRec(underlying, "underlying");
       } else {
+        // This can't actually happen
         printFlag("unresolved_underlying");
       }
 
       if (T->getParent())
         printRec(T->getParent(), "parent");
-      printRecRange(T->getDirectGenericArgs(), "direct_generic_args");
+      for (auto arg : T->getDirectGenericArgs())
+        printRec(arg);
 
       printFoot();
     }

lib/AST/ASTVerifier.cpp

@@ -2879,40 +2879,6 @@ class Verifier : public ASTWalker {
           continue;
         }
       }
-
-      // Make sure we have the right signature conformances.
-      if (!normal->isInvalid()){
-        auto conformances = normal->getSignatureConformances();
-        unsigned idx = 0;
-        auto reqs = proto->getRequirementSignature().getRequirements();
-        for (const auto &req : reqs) {
-          if (req.getKind() != RequirementKind::Conformance)
-            continue;
-
-          if (idx >= conformances.size()) {
-            Out << "error: not enough conformances for requirement signature\n";
-            normal->dump(Out);
-            abort();
-          }
-
-          auto reqProto = req.getProtocolDecl();
-          if (reqProto != conformances[idx].getRequirement()) {
-            Out << "error: wrong protocol in signature conformances: have "
-              << conformances[idx].getRequirement()->getName().str()
-              << ", expected " << reqProto->getName().str()<< "\n";
-            normal->dump(Out);
-            abort();
-          }
-
-          ++idx;
-        }
-
-        if (idx != conformances.size()) {
-          Out << "error: too many conformances for requirement signature\n";
-          normal->dump(Out);
-          abort();
-        }
-      }
     }
 
     void verifyChecked(GenericTypeDecl *generic) {

lib/AST/PrettyStackTrace.cpp

@@ -273,10 +273,11 @@ void swift::printConformanceDescription(llvm::raw_ostream &out,
     return;
   }
 
-  out << "protocol conformance to ";
-  printDeclDescription(out, conformance->getProtocol(), /*newline*/false);
-  out << " for ";
-  printTypeDescription(out, conformance->getType(), ctxt, addNewline);
+  out << "protocol conformance "
+      << conformance->getType() << ": "
+      << conformance->getProtocol()->getName() << " at ";
+  auto *decl = conformance->getDeclContext()->getInnermostDeclarationDeclContext();
+  printDeclDescription(out, decl, addNewline);
 }
 
 void swift::printSourceLocDescription(llvm::raw_ostream &out,