RequirementMachine: Implement RequirementMachine::initWithProtocolSignatureRequirements()

Author: slavapestov

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -1089,6 +1089,51 @@ void RuleBuilder::initWithWrittenRequirements(
     addRequirement(req, /*proto=*/nullptr);
 }
 
+/// For building a rewrite system for a protocol connected component from
+/// a previously-built requirement signature.
+///
+/// Will trigger requirement signature computation if we haven't built
+/// requirement signatures for this connected component yet, in which case we
+/// will recursively end up building another rewrite system for this component
+/// using initWithProtocolWrittenRequirements().
+void RuleBuilder::initWithProtocolSignatureRequirements(
+    ArrayRef<const ProtocolDecl *> protos) {
+  assert(!Initialized);
+  Initialized = 1;
+
+  // Add all protocols to the referenced set, so that subsequent calls
+  // to addReferencedProtocol() with one of these protocols don't add
+  // them to the import list.
+  for (auto *proto : protos) {
+    ReferencedProtocols.insert(proto);
+  }
+
+  for (auto *proto : protos) {
+    if (Dump) {
+      llvm::dbgs() << "protocol " << proto->getName() << " {\n";
+    }
+
+    addPermanentProtocolRules(proto);
+
+    auto reqs = proto->getRequirementSignature();
+    for (auto req : reqs.getRequirements())
+      addRequirement(req.getCanonical(), proto, /*requirementID=*/None);
+    for (auto alias : reqs.getTypeAliases())
+      addTypeAlias(alias, proto);
+
+    for (auto *otherProto : proto->getProtocolDependencies())
+      addReferencedProtocol(otherProto);
+
+    if (Dump) {
+      llvm::dbgs() << "}\n";
+    }
+  }
+
+  // Collect all protocols transitively referenced from this connected component
+  // of the protocol dependency graph.
+  collectRulesFromReferencedProtocols();
+}
+
 /// For building a rewrite system for a protocol connected component from
 /// user-written requirements. Used when actually building requirement
 /// signatures.
@@ -1097,6 +1142,9 @@ void RuleBuilder::initWithProtocolWrittenRequirements(
   assert(!Initialized);
   Initialized = 1;
 
+  // Add all protocols to the referenced set, so that subsequent calls
+  // to addReferencedProtocol() with one of these protocols don't add
+  // them to the import list.
   for (auto *proto : protos) {
     ReferencedProtocols.insert(proto);
   }

lib/AST/RequirementMachine/RequirementLowering.h

@@ -125,6 +125,7 @@ struct RuleBuilder {
 
   void initWithGenericSignatureRequirements(ArrayRef<Requirement> requirements);
   void initWithWrittenRequirements(ArrayRef<StructuralRequirement> requirements);
+  void initWithProtocolSignatureRequirements(ArrayRef<const ProtocolDecl *> proto);
   void initWithProtocolWrittenRequirements(ArrayRef<const ProtocolDecl *> proto);
   void addReferencedProtocol(const ProtocolDecl *proto);
   void collectRulesFromReferencedProtocols();

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -63,6 +63,46 @@ void RequirementMachine::checkCompletionResult(CompletionResult result) const {
   }
 }
 
+/// Build a requirement machine for the previously-computed requirement
+/// signatures connected component of protocols.
+///
+/// This must only be called exactly once, before any other operations are
+/// performed on this requirement machine.
+///
+/// Used by RewriteContext::getRequirementMachine(const ProtocolDecl *).
+///
+/// Returns failure if completion fails within the configured number of steps.
+std::pair<CompletionResult, unsigned>
+RequirementMachine::initWithProtocolSignatureRequirements(
+    ArrayRef<const ProtocolDecl *> protos) {
+  FrontendStatsTracer tracer(Stats, "build-rewrite-system");
+
+  if (Dump) {
+    llvm::dbgs() << "Adding protocols";
+    for (auto *proto : protos) {
+      llvm::dbgs() << " " << proto->getName();
+    }
+    llvm::dbgs() << " {\n";
+  }
+
+  RuleBuilder builder(Context, System.getReferencedProtocols());
+  builder.initWithProtocolSignatureRequirements(protos);
+
+  // Add the initial set of rewrite rules to the rewrite system.
+  System.initialize(/*recordLoops=*/true, protos,
+                    std::move(builder.WrittenRequirements),
+                    std::move(builder.PermanentRules),
+                    std::move(builder.RequirementRules));
+
+  auto result = computeCompletion(RewriteSystem::DisallowInvalidRequirements);
+
+  if (Dump) {
+    llvm::dbgs() << "}\n";
+  }
+
+  return result;
+}
+
 /// Build a requirement machine for the requirements of a generic signature.
 ///
 /// In this mode, minimization is not going to be performed, so rewrite loops
@@ -109,12 +149,12 @@ RequirementMachine::initWithGenericSignature(CanGenericSignature sig) {
   return result;
 }
 
-/// Build a requirement machine for the structural requirements of a set
-/// of protocols, which are understood to form a strongly-connected component
-/// (SCC) of the protocol dependency graph.
+/// Build a requirement machine for the user-written requirements of connected
+/// component of protocols.
 ///
-/// In this mode, minimization will be performed, so rewrite loops are recorded
-/// during completion.
+/// This is used when actually building the requirement signatures of these
+/// protocols. In this mode, minimization will be performed, so rewrite loops
+/// are recorded during completion.
 ///
 /// This must only be called exactly once, before any other operations are
 /// performed on this requirement machine.

lib/AST/RequirementMachine/RequirementMachine.h

@@ -90,6 +90,10 @@ class RequirementMachine final {
 
   void checkCompletionResult(CompletionResult result) const;
 
+  std::pair<CompletionResult, unsigned>
+  initWithProtocolSignatureRequirements(
+      ArrayRef<const ProtocolDecl *> protos);
+
   std::pair<CompletionResult, unsigned>
   initWithGenericSignature(CanGenericSignature sig);