Merge pull request #42042 from slavapestov/rqm-reuse-machines

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

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/Debug.h

@@ -69,6 +69,9 @@ enum class DebugFlags : unsigned {
   /// Print debug output from propagating explicit requirement
   /// IDs from redundant rules.
   PropagateRequirementIDs = (1<<15),
+
+  /// Print a trace of requirement machines constructed and how long each took.
+  Timers = (1<<16),
 };
 
 using DebugOptions = OptionSet<DebugFlags>;

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

@@ -90,14 +90,16 @@ RequirementMachine::initWithProtocolSignatureRequirements(
   builder.initWithProtocolSignatureRequirements(protos);
 
   // Add the initial set of rewrite rules to the rewrite system.
-  System.initialize(/*recordLoops=*/true, protos,
+  System.initialize(/*recordLoops=*/false, protos,
                     std::move(builder.WrittenRequirements),
                     std::move(builder.ImportedRules),
                     std::move(builder.PermanentRules),
                     std::move(builder.RequirementRules));
 
   auto result = computeCompletion(RewriteSystem::DisallowInvalidRequirements);
 
+  freeze();
+
   if (Dump) {
     llvm::dbgs() << "}\n";
   }
@@ -145,6 +147,8 @@ RequirementMachine::initWithGenericSignature(CanGenericSignature sig) {
 
   auto result = computeCompletion(RewriteSystem::DisallowInvalidRequirements);
 
+  freeze();
+
   if (Dump) {
     llvm::dbgs() << "}\n";
   }
@@ -332,6 +336,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);
@@ -359,19 +367,18 @@ void RequirementMachine::dump(llvm::raw_ostream &out) const {
   out << "Requirement machine for ";
   if (Sig)
     out << Sig;
-  else if (!Params.empty()) {
-    out << "fresh signature <";
-    for (auto paramTy : Params)
-      out << " " << Type(paramTy);
-    out << " >";
-  } else {
+  else if (!System.getProtocols().empty()) {
     auto protos = System.getProtocols();
-    assert(!protos.empty());
     out << "protocols [";
     for (auto *proto : protos) {
       out << " " << proto->getName();
     }
     out << " ]";
+  } else {
+    out << "fresh signature <";
+    for (auto paramTy : Params)
+      out << " " << Type(paramTy);
+    out << " >";
   }
   out << "\n";
 

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;