RequirementMachine: Re-use requirement machines constructed by minimization for queries

Fixes rdar://problem/88135641.

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -535,13 +535,16 @@ GenericSignature buildGenericSignature(
 
 /// Summary of error conditions detected by the Requirement Machine.
 enum class GenericSignatureErrorFlags {
-  /// The original requirements referenced a non-existent type parameter.
-  HasUnresolvedType = (1<<0),
-
-  /// The original requirements were in conflict with each other, meaning
+  /// The original requirements referenced a non-existent type parameter,
+  /// or the original requirements were in conflict with each other, meaning
   /// there are no possible concrete substitutions which statisfy the
   /// generic signature.
-  HasConflict = (1<<1),
+  HasInvalidRequirements = (1<<0),
+
+  /// The generic signature had non-redundant concrete conformance
+  /// requirements, which means the rewrite system used for minimization
+  /// must be discarded and a new one built for queries.
+  HasConcreteConformances = (1<<1),
 
   /// The Knuth-Bendix completion procedure failed to construct a confluent
   /// rewrite system.

lib/AST/GenericSignature.cpp

@@ -1067,7 +1067,9 @@ void swift::validateGenericSignature(ASTContext &context,
         GenericSignatureWithError());
 
     // If there were any errors, the signature was invalid.
-    if (newSigWithError.getInt()) {
+    auto errorFlags = newSigWithError.getInt();
+    if (errorFlags.contains(GenericSignatureErrorFlags::HasInvalidRequirements) ||
+        errorFlags.contains(GenericSignatureErrorFlags::CompletionFailed)) {
       context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_valid,
                              sig->getAsString());
     }

lib/AST/GenericSignatureBuilder.cpp

@@ -8275,7 +8275,7 @@ AbstractGenericSignatureRequest::evaluate(
     if (!rqmResult.getPointer() && !gsbResult.getPointer())
       return rqmResult;
 
-    if (!rqmResult.getInt().contains(GenericSignatureErrorFlags::HasConflict) &&
+    if (!rqmResult.getInt().contains(GenericSignatureErrorFlags::HasInvalidRequirements) &&
         !rqmResult.getInt().contains(GenericSignatureErrorFlags::CompletionFailed) &&
         !rqmResult.getPointer()->isEqual(gsbResult.getPointer())) {
       PrintOptions opts;
@@ -8427,7 +8427,7 @@ AbstractGenericSignatureRequestGSB::evaluate(
 
   GenericSignatureErrors errorFlags;
   if (builder.hadAnyError())
-    errorFlags |= GenericSignatureErrorFlags::HasUnresolvedType;
+    errorFlags |= GenericSignatureErrorFlags::HasInvalidRequirements;
   auto result = std::move(builder).computeGenericSignature(
       /*allowConcreteGenericParams=*/true);
   return GenericSignatureWithError(result, errorFlags);
@@ -8489,7 +8489,7 @@ InferredGenericSignatureRequest::evaluate(
     if (!rqmResult.getPointer() && !gsbResult.getPointer())
       return rqmResult;
 
-    if (!rqmResult.getInt().contains(GenericSignatureErrorFlags::HasConflict) &&
+    if (!rqmResult.getInt().contains(GenericSignatureErrorFlags::HasInvalidRequirements) &&
         !rqmResult.getInt().contains(GenericSignatureErrorFlags::CompletionFailed) &&
         !rqmResult.getPointer()->isEqual(gsbResult.getPointer())) {
       PrintOptions opts;
@@ -8635,7 +8635,7 @@ InferredGenericSignatureRequestGSB::evaluate(
 
   GenericSignatureErrors errorFlags;
   if (builder.hadAnyError())
-    errorFlags |= GenericSignatureErrorFlags::HasUnresolvedType;
+    errorFlags |= GenericSignatureErrorFlags::HasInvalidRequirements;
   auto result = std::move(builder).computeGenericSignature(
       allowConcreteGenericParams);
   return GenericSignatureWithError(result, errorFlags);
@@ -8705,7 +8705,7 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
     auto rqmResult = buildViaRQM();
     auto gsbResult = buildViaGSB();
 
-    if (!rqmResult.getErrors().contains(GenericSignatureErrorFlags::HasConflict) &&
+    if (!rqmResult.getErrors().contains(GenericSignatureErrorFlags::HasInvalidRequirements) &&
         !rqmResult.getErrors().contains(GenericSignatureErrorFlags::CompletionFailed) &&
         !compare(rqmResult.getRequirements(),
                  gsbResult.getRequirements())) {

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -471,6 +471,7 @@ void RewriteSystem::minimizeRewriteSystem() {
 
   assert(Complete);
   assert(!Minimized);
+  assert(!Frozen);
   Minimized = 1;
 
   propagateExplicitBits();
@@ -626,7 +627,7 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
 
   GenericSignatureErrors result;
 
-  for (const auto &rule : Rules) {
+  for (const auto &rule : getLocalRules()) {
     if (rule.isPermanent())
       continue;
 
@@ -636,10 +637,15 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
     if (!rule.isRedundant() &&
         !rule.isProtocolTypeAliasRule() &&
         rule.containsUnresolvedSymbols())
-      result |= GenericSignatureErrorFlags::HasUnresolvedType;
+      result |= GenericSignatureErrorFlags::HasInvalidRequirements;
 
     if (rule.isConflicting())
-      result |= GenericSignatureErrorFlags::HasConflict;
+      result |= GenericSignatureErrorFlags::HasInvalidRequirements;
+
+    if (!rule.isRedundant())
+      if (auto property = rule.isPropertyRule())
+        if (property->getKind() == Symbol::Kind::ConcreteConformance)
+          result |= GenericSignatureErrorFlags::HasConcreteConformances;
   }
 
   return result;

lib/AST/RequirementMachine/KnuthBendix.cpp

@@ -287,6 +287,7 @@ RewriteSystem::computeConfluentCompletion(unsigned maxRuleCount,
                                           unsigned maxRuleLength) {
   assert(Initialized);
   assert(!Minimized);
+  assert(!Frozen);
 
   // Complete might already be set, if we're re-running completion after
   // adding new rules in the property map's concrete type unification procedure.

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -332,6 +332,10 @@ RequirementMachine::computeCompletion(RewriteSystem::ValidityPolicy policy) {
   return std::make_pair(CompletionResult::Success, 0);
 }
 
+void RequirementMachine::freeze() {
+  System.freeze();
+}
+
 std::string RequirementMachine::getRuleAsStringForDiagnostics(
     unsigned ruleID) const {
   const auto &rule = System.getRule(ruleID);

lib/AST/RequirementMachine/RequirementMachine.h

@@ -113,6 +113,8 @@ class RequirementMachine final {
   std::pair<CompletionResult, unsigned>
   computeCompletion(RewriteSystem::ValidityPolicy policy);
 
+  void freeze();
+
   MutableTerm getLongestValidPrefix(const MutableTerm &term) const;
 
   void buildRequirementsFromRules(
@@ -159,8 +161,8 @@ class RequirementMachine final {
   llvm::DenseMap<const ProtocolDecl *, RequirementSignature>
   computeMinimalProtocolRequirements();
 
-  std::vector<Requirement>
-  computeMinimalGenericSignatureRequirements(bool reconstituteSugar);
+  GenericSignature
+  computeMinimalGenericSignature(bool reconstituteSugar);
 
   ArrayRef<Rule> getLocalRules() const;
 

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -288,7 +288,8 @@ RequirementSignatureRequestRQM::evaluate(Evaluator &evaluator,
 
     auto minimalRequirements = machine->computeMinimalProtocolRequirements();
 
-    if (!machine->getErrors()) {
+    if (!machine->getErrors().contains(
+          GenericSignatureErrorFlags::HasInvalidRequirements)) {
       if (shouldSplitConcreteEquivalenceClasses(minimalRequirements, machine.get())) {
         ++attempt;
         splitConcreteEquivalenceClasses(ctx, minimalRequirements,
@@ -345,15 +346,20 @@ RequirementSignatureRequestRQM::evaluate(Evaluator &evaluator,
                                 /*allowConcreteGenericParams=*/false);
     }
 
+    if (!machine->getErrors())
+      rewriteCtx.installRequirementMachine(proto, std::move(machine));
+
     // Return the result for the specific protocol this request was kicked off on.
     return *result;
   }
 }
 
 /// Builds the top-level generic signature requirements for this rewrite system.
-std::vector<Requirement>
-RequirementMachine::computeMinimalGenericSignatureRequirements(
+GenericSignature
+RequirementMachine::computeMinimalGenericSignature(
     bool reconstituteSugar) {
+  assert(!Sig &&
+         "Already computed minimal generic signature");
   assert(System.getProtocols().empty() &&
          "Not a top-level generic signature rewrite system");
   assert(!Params.empty() &&
@@ -375,7 +381,14 @@ RequirementMachine::computeMinimalGenericSignatureRequirements(
                              reconstituteSugar, reqs, aliases);
   assert(aliases.empty());
 
-  return reqs;
+  auto sig = GenericSignature::get(getGenericParams(), reqs);
+
+  // Remember the signature for generic signature queries. In particular,
+  // getConformanceAccessPath() needs the current requirement machine's
+  // generic signature.
+  Sig = sig.getCanonicalSignature();
+
+  return sig;
 }
 
 /// Check whether the inputs to the \c AbstractGenericSignatureRequest are
@@ -549,14 +562,11 @@ AbstractGenericSignatureRequestRQM::evaluate(
 
     // We pass reconstituteSugar=false to ensure that if the original
     // requirements were canonical, the final signature remains canonical.
-    auto minimalRequirements =
-      machine->computeMinimalGenericSignatureRequirements(
+    auto result = machine->computeMinimalGenericSignature(
           /*reconstituteSugar=*/false);
-
-    auto result = GenericSignature::get(genericParams, minimalRequirements);
     auto errorFlags = machine->getErrors();
 
-    if (!errorFlags) {
+    if (!errorFlags.contains(GenericSignatureErrorFlags::HasInvalidRequirements)) {
       if (shouldSplitConcreteEquivalenceClasses(result.getRequirements(),
                                                 /*proto=*/nullptr,
                                                 machine.get())) {
@@ -567,7 +577,19 @@ AbstractGenericSignatureRequestRQM::evaluate(
                                         requirements, attempt);
         continue;
       }
+    }
 
+    if (!errorFlags) {
+      // If this signature was minimized without errors or non-redundant
+      // concrete conformances, we can re-use the requirement machine for
+      // subsequent queries, instead of building a new requirement machine
+      // from the minimized signature. Do this before verify(), which
+      // performs queries.
+      rewriteCtx.installRequirementMachine(result.getCanonicalSignature(),
+                                           std::move(machine));
+    }
+
+    if (!errorFlags.contains(GenericSignatureErrorFlags::HasInvalidRequirements)) {
       // Check invariants.
       result.verify();
     }
@@ -731,11 +753,8 @@ InferredGenericSignatureRequestRQM::evaluate(
           result, GenericSignatureErrorFlags::CompletionFailed);
     }
 
-    auto minimalRequirements =
-      machine->computeMinimalGenericSignatureRequirements(
+    auto result = machine->computeMinimalGenericSignature(
           /*reconstituteSugar=*/true);
-
-    auto result = GenericSignature::get(genericParams, minimalRequirements);
     auto errorFlags = machine->getErrors();
 
     if (attempt == 0 &&
@@ -747,7 +766,7 @@ InferredGenericSignatureRequestRQM::evaluate(
 
     // FIXME: Handle allowConcreteGenericParams
 
-    if (!errorFlags) {
+    if (!errorFlags.contains(GenericSignatureErrorFlags::HasInvalidRequirements)) {
       // Check if we need to rebuild the signature.
       if (shouldSplitConcreteEquivalenceClasses(result.getRequirements(),
                                                 /*proto=*/nullptr,
@@ -759,7 +778,19 @@ InferredGenericSignatureRequestRQM::evaluate(
                                         requirements, attempt);
         continue;
       }
+    }
+
+    if (!errorFlags) {
+      // If this signature was minimized without errors or non-redundant
+      // concrete conformances, we can re-use the requirement machine for
+      // subsequent queries, instead of building a new requirement machine
+      // from the minimized signature. Do this before verify(), which
+      // performs queries.
+      rewriteCtx.installRequirementMachine(result.getCanonicalSignature(),
+                                           std::move(machine));
+    }
 
+    if (!errorFlags.contains(GenericSignatureErrorFlags::HasInvalidRequirements)) {
       // Check invariants.
       result.verify();
     }

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -195,6 +195,21 @@ bool RewriteContext::isRecursivelyConstructingRequirementMachine(
   return !found->second->isComplete();
 }
 
+/// Given a requirement machine that built a minimized signature, attempt to
+/// re-use it for subsequent queries against the minimized signature, instead
+/// of building a new one later.
+void RewriteContext::installRequirementMachine(
+    CanGenericSignature sig,
+    std::unique_ptr<RequirementMachine> machine) {
+  auto *machinePtr = machine.release();
+
+  machinePtr->freeze();
+
+  auto inserted = Machines.insert(std::make_pair(sig, machinePtr)).second;
+  if (!inserted)
+    delete machinePtr;
+}
+
 /// Implement Tarjan's algorithm to compute strongly-connected components in
 /// the protocol dependency graph.
 void RewriteContext::getProtocolComponentRec(
@@ -370,6 +385,11 @@ void RewriteContext::finishComputingRequirementSignatures(
 /// for being built with the same component.
 RequirementMachine *RewriteContext::getRequirementMachine(
     const ProtocolDecl *proto) {
+  // First, get the requirement signature. If this protocol was written in
+  // source, we'll minimize it and install the machine below, saving us the
+  // effort of recomputing it.
+  (void) proto->getRequirementSignature();
+
   auto &component = getProtocolComponentImpl(proto);
 
   if (component.Machine) {
@@ -435,6 +455,24 @@ bool RewriteContext::isRecursivelyConstructingRequirementMachine(
           !component->second.ComputedRequirementSignatures);
 }
 
+/// Given a reuirement machine that built the requirement signatures for a
+/// protocol connected component, attempt to re-use it for subsequent
+/// queries against the connected component, instead of building a new one
+/// later.
+void RewriteContext::installRequirementMachine(
+    const ProtocolDecl *proto,
+    std::unique_ptr<RequirementMachine> machine) {
+  auto *machinePtr = machine.release();
+
+  machinePtr->freeze();
+
+  auto &component = getProtocolComponentImpl(proto);
+  if (component.Machine == nullptr)
+    component.Machine = machinePtr;
+  else
+    delete machinePtr;
+}
+
 /// We print stats in the destructor, which should get executed at the end of
 /// a compilation job.
 RewriteContext::~RewriteContext() {

lib/AST/RequirementMachine/RewriteContext.h

@@ -206,6 +206,9 @@ class RewriteContext final {
   RequirementMachine *getRequirementMachine(CanGenericSignature sig);
   bool isRecursivelyConstructingRequirementMachine(CanGenericSignature sig);
 
+  void installRequirementMachine(CanGenericSignature sig,
+                                 std::unique_ptr<RequirementMachine> machine);
+
   ArrayRef<const ProtocolDecl *>
   startComputingRequirementSignatures(const ProtocolDecl *proto);
 
@@ -214,6 +217,9 @@ class RewriteContext final {
   RequirementMachine *getRequirementMachine(const ProtocolDecl *proto);
   bool isRecursivelyConstructingRequirementMachine(const ProtocolDecl *proto);
 
+  void installRequirementMachine(const ProtocolDecl *proto,
+                                 std::unique_ptr<RequirementMachine> machine);
+
   ~RewriteContext();
 };