RequirementMachine: Add RequirementMachine::initWithWrittenRequirements()

Author: slavapestov

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -692,6 +692,21 @@ void RuleBuilder::addRequirements(ArrayRef<Requirement> requirements) {
     addRequirement(req, /*proto=*/nullptr);
 }
 
+void RuleBuilder::addRequirements(ArrayRef<StructuralRequirement> requirements) {
+  // Collect all protocols transitively referenced from these requirements.
+  for (auto req : requirements) {
+    if (req.req.getKind() == RequirementKind::Conformance) {
+      addProtocol(req.req.getProtocolDecl(), /*initialComponent=*/false);
+    }
+  }
+
+  collectRulesFromReferencedProtocols();
+
+  // Add rewrite rules for all top-level requirements.
+  for (const auto &req : requirements)
+    addRequirement(req, /*proto=*/nullptr);
+}
+
 void RuleBuilder::addProtocols(ArrayRef<const ProtocolDecl *> protos) {
   // Collect all protocols transitively referenced from this connected component
   // of the protocol dependency graph.
@@ -849,6 +864,12 @@ void RuleBuilder::addRequirement(const Requirement &req,
   RequirementRules.emplace_back(subjectTerm, constraintTerm);
 }
 
+void RuleBuilder::addRequirement(const StructuralRequirement &req,
+                                 const ProtocolDecl *proto) {
+  // FIXME: Preserve source location information for diagnostics.
+  addRequirement(req.req.getCanonical(), proto);
+}
+
 /// Record information about a protocol if we have no seen it yet.
 void RuleBuilder::addProtocol(const ProtocolDecl *proto,
                               bool initialComponent) {
@@ -902,10 +923,8 @@ void RuleBuilder::collectRulesFromReferencedProtocols() {
     // we can trigger the computation of the requirement signatures of the
     // next component recursively.
     if (ProtocolMap[proto]) {
-      // FIXME: Keep source location information around for redundancy
-      // diagnostics.
       for (auto req : proto->getStructuralRequirements())
-        addRequirement(req.req.getCanonical(), proto);
+        addRequirement(req, proto);
 
       for (auto req : proto->getTypeAliasRequirements())
         addRequirement(req.getCanonical(), proto);

lib/AST/RequirementMachine/RequirementLowering.h

@@ -93,13 +93,16 @@ struct RuleBuilder {
 
   RuleBuilder(RewriteContext &ctx, bool dump) : Context(ctx), Dump(dump) {}
   void addRequirements(ArrayRef<Requirement> requirements);
+  void addRequirements(ArrayRef<StructuralRequirement> requirements);
   void addProtocols(ArrayRef<const ProtocolDecl *> proto);
   void addProtocol(const ProtocolDecl *proto,
                    bool initialComponent);
   void addAssociatedType(const AssociatedTypeDecl *type,
                          const ProtocolDecl *proto);
   void addRequirement(const Requirement &req,
                       const ProtocolDecl *proto);
+  void addRequirement(const StructuralRequirement &req,
+                      const ProtocolDecl *proto);
   void collectRulesFromReferencedProtocols();
 };
 

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -257,6 +257,44 @@ void RequirementMachine::initWithAbstractRequirements(
   }
 }
 
+/// Build a requirement machine from a set of generic parameters and
+/// structural requirements.
+///
+/// This must only be called exactly once, before any other operations are
+/// performed on this requirement machine.
+///
+/// Used by InferredGenericSignatureRequest.
+void RequirementMachine::initWithWrittenRequirements(
+    ArrayRef<GenericTypeParamType *> genericParams,
+    ArrayRef<StructuralRequirement> requirements) {
+  Params.append(genericParams.begin(), genericParams.end());
+
+  FrontendStatsTracer tracer(Stats, "build-rewrite-system");
+
+  if (Dump) {
+    llvm::dbgs() << "Adding generic parameters:";
+    for (auto *paramTy : genericParams)
+      llvm::dbgs() << " " << Type(paramTy);
+    llvm::dbgs() << "\n";
+  }
+
+  // Collect the top-level requirements, and all transtively-referenced
+  // protocol requirement signatures.
+  RuleBuilder builder(Context, Dump);
+  builder.addRequirements(requirements);
+
+  // Add the initial set of rewrite rules to the rewrite system.
+  System.initialize(/*recordLoops=*/true,
+                    std::move(builder.PermanentRules),
+                    std::move(builder.RequirementRules));
+
+  computeCompletion(RewriteSystem::AllowInvalidRequirements);
+
+  if (Dump) {
+    llvm::dbgs() << "}\n";
+  }
+}
+
 /// Attempt to obtain a confluent rewrite system by iterating the Knuth-Bendix
 /// completion procedure together with property map construction until fixed
 /// point.

lib/AST/RequirementMachine/RequirementMachine.h

@@ -86,6 +86,9 @@ class RequirementMachine final {
   void initWithAbstractRequirements(
       ArrayRef<GenericTypeParamType *> genericParams,
       ArrayRef<Requirement> requirements);
+  void initWithWrittenRequirements(
+      ArrayRef<GenericTypeParamType *> genericParams,
+      ArrayRef<StructuralRequirement> requirements);
 
   bool isComplete() const;