RequirementMachine: Wire up protocol requirement signature minimization

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "RequirementMachine.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignatureBuilder.h"
@@ -23,6 +24,7 @@
 #include "swift/Basic/Statistic.h"
 
 using namespace swift;
+using namespace rewriting;
 
 #define DEBUG_TYPE "Serialization"
 
@@ -54,27 +56,82 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
     return ctx.AllocateCopy(requirements);
   }
 
-  GenericSignatureBuilder builder(proto->getASTContext());
-
-  // Add all of the generic parameters.
-  for (auto gp : *proto->getGenericParams())
-    builder.addGenericParameter(gp);
-
-  // Add the conformance of 'self' to the protocol.
-  auto selfType =
-    proto->getSelfInterfaceType()->castTo<GenericTypeParamType>();
-  auto requirement =
-    Requirement(RequirementKind::Conformance, selfType,
-                proto->getDeclaredInterfaceType());
-
-  builder.addRequirement(
-          requirement,
-          GenericSignatureBuilder::RequirementSource::forRequirementSignature(
-                                                      builder, selfType, proto),
-          nullptr);
-
-  auto reqSignature = std::move(builder).computeGenericSignature(
-                        /*allowConcreteGenericParams=*/false,
-                        /*requirementSignatureSelfProto=*/proto);
-  return reqSignature.getRequirements();
+  auto buildViaGSB = [&]() {
+    GenericSignatureBuilder builder(proto->getASTContext());
+
+    // Add all of the generic parameters.
+    for (auto gp : *proto->getGenericParams())
+      builder.addGenericParameter(gp);
+
+    // Add the conformance of 'self' to the protocol.
+    auto selfType =
+      proto->getSelfInterfaceType()->castTo<GenericTypeParamType>();
+    auto requirement =
+      Requirement(RequirementKind::Conformance, selfType,
+                  proto->getDeclaredInterfaceType());
+
+    builder.addRequirement(
+            requirement,
+            GenericSignatureBuilder::RequirementSource::forRequirementSignature(
+                                                        builder, selfType, proto),
+            nullptr);
+
+    auto reqSignature = std::move(builder).computeGenericSignature(
+                          /*allowConcreteGenericParams=*/false,
+                          /*requirementSignatureSelfProto=*/proto);
+    return reqSignature.getRequirements();
+  };
+
+  auto buildViaRQM = [&]() {
+    // We build requirement signatures for all protocols in a strongly connected
+    // component at the same time.
+    auto *machine = ctx.getOrCreateRequirementMachine(proto);
+    auto requirements = machine->computeMinimalRequirements();
+
+    bool debug = machine->getDebugOptions().contains(DebugFlags::Minimization);
+
+    // The requirement signature for the actual protocol that the result
+    // was kicked off with.
+    ArrayRef<Requirement> result;
+
+    for (const auto &pair : requirements) {
+      auto *otherProto = pair.first;
+      const auto &reqs = pair.second;
+
+      // setRequirementSignature() doesn't take ownership of the memory, so
+      // we have to make a copy of the std::vector temporary.
+      ArrayRef<Requirement> reqsCopy = ctx.AllocateCopy(reqs);
+
+      // Don't call setRequirementSignature() on the original proto; the
+      // request evaluator will do it for us.
+      if (otherProto == proto)
+        result = reqsCopy;
+      else
+        const_cast<ProtocolDecl *>(otherProto)->setRequirementSignature(reqsCopy);
+
+      // Dump the result if requested.
+      if (debug) {
+        llvm::dbgs() << "Protocol " << otherProto->getName() << ": ";
+
+        auto sig = GenericSignature::get(
+            otherProto->getGenericSignature().getGenericParams(),
+            reqsCopy);
+        llvm::dbgs() << sig << "\n";
+      }
+    }
+
+    // Return the result for the specific protocol this request was kicked off on.
+    return result;
+  };
+
+  switch (ctx.LangOpts.RequirementMachineProtocolSignatures) {
+  case RequirementMachineMode::Disabled:
+    return buildViaGSB();
+
+  case RequirementMachineMode::Enabled:
+    return buildViaRQM();
+
+  case RequirementMachineMode::Verify:
+    abort();
+  }
 }