Merge pull request #40150 from slavapestov/rqm-generic-signature-minimization-1

RequirementMachine: Sketch out top-level generic signature minimization

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -140,7 +140,7 @@ namespace namelookup {
 }
 
 namespace rewriting {
-  class RequirementMachine;
+  class RewriteContext;
 }
 
 namespace syntax {
@@ -1215,21 +1215,13 @@ class ASTContext final {
   GenericSignatureBuilder *getOrCreateGenericSignatureBuilder(
                                                      CanGenericSignature sig);
 
-  /// Retrieve or create a term rewriting system for answering queries on
-  /// type parameters written against the given generic signature.
-  rewriting::RequirementMachine *getOrCreateRequirementMachine(
-      CanGenericSignature sig);
+  rewriting::RewriteContext &getRewriteContext();
 
   /// This is a hack to break cycles. Don't introduce new callers of this
   /// method.
   bool isRecursivelyConstructingRequirementMachine(
       CanGenericSignature sig);
 
-  /// Retrieve or create a term rewriting system for answering queries on
-  /// type parameters written against the given protocol requirement signature.
-  rewriting::RequirementMachine *getOrCreateRequirementMachine(
-      const ProtocolDecl *proto);
-
   /// Retrieve a generic signature with a single unconstrained type parameter,
   /// like `<T>`.
   CanGenericSignature getSingleGenericParameterSignature() const;

include/swift/AST/TypeCheckRequests.h

@@ -406,8 +406,9 @@ class ProtocolDependenciesRequest :
   bool isCached() const { return true; }
 };
 
-/// Compute the requirements that describe a protocol using the
-/// RequirementMachine.
+/// Compute a protocol's requirement signature using the RequirementMachine.
+/// This is temporary; once the GenericSignatureBuilder goes away this will
+/// be folded into RequirementSignatureRequest.
 class RequirementSignatureRequestRQM :
     public SimpleRequest<RequirementSignatureRequestRQM,
                          ArrayRef<Requirement>(ProtocolDecl *),
@@ -1466,6 +1467,38 @@ class AbstractGenericSignatureRequest :
   }
 };
 
+/// Build a generic signature using the RequirementMachine. This is temporary;
+/// once the GenericSignatureBuilder goes away this will be folded into
+/// AbstractGenericSignatureRequest.
+class AbstractGenericSignatureRequestRQM :
+    public SimpleRequest<AbstractGenericSignatureRequestRQM,
+                         GenericSignatureWithError (const GenericSignatureImpl *,
+                                                    SmallVector<GenericTypeParamType *, 2>,
+                                                    SmallVector<Requirement, 2>),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  GenericSignatureWithError
+  evaluate(Evaluator &evaluator,
+           const GenericSignatureImpl *baseSignature,
+           SmallVector<GenericTypeParamType *, 2> addedParameters,
+           SmallVector<Requirement, 2> addedRequirements) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+
+  /// Abstract generic signature requests never have source-location info.
+  SourceLoc getNearestLoc() const {
+    return SourceLoc();
+  }
+};
+
 class InferredGenericSignatureRequest :
     public SimpleRequest<InferredGenericSignatureRequest,
                          GenericSignatureWithError (ModuleDecl *,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -20,6 +20,11 @@ SWIFT_REQUEST(TypeChecker, AbstractGenericSignatureRequest,
                                          SmallVector<GenericTypeParamType *, 2>,
                                          SmallVector<Requirement, 2>),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, AbstractGenericSignatureRequestRQM,
+              GenericSignatureWithError (const GenericSignatureImpl *,
+                                         SmallVector<GenericTypeParamType *, 2>,
+                                         SmallVector<Requirement, 2>),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ApplyAccessNoteRequest,
               evaluator::SideEffect(ValueDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, AttachedResultBuilderRequest,

include/swift/Basic/LangOptions.h

@@ -473,11 +473,11 @@ namespace swift {
     /// Enables fine-grained debug output from the requirement machine.
     std::string DebugRequirementMachine;
 
-    /// Maximum iteration count for requirement machine confluent completion
+    /// Maximum iteration count for requirement machine Knuth-Bendix completion
     /// algorithm.
     unsigned RequirementMachineStepLimit = 4000;
 
-    /// Maximum term length for requirement machine confluent completion
+    /// Maximum term length for requirement machine Knuth-Bendix completion
     /// algorithm.
     unsigned RequirementMachineDepthLimit = 10;
 
@@ -486,6 +486,10 @@ namespace swift {
     RequirementMachineMode RequirementMachineProtocolSignatures =
         RequirementMachineMode::Disabled;
 
+    /// Enable the new experimental generic signature minimization algorithm.
+    RequirementMachineMode RequirementMachineGenericSignatures =
+        RequirementMachineMode::Disabled;
+
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Option/Options.td

@@ -624,6 +624,10 @@ def requirement_machine_protocol_signatures_EQ : Joined<["-"], "requirement-mach
   Flags<[FrontendOption]>,
   HelpText<"Control usage of experimental protocol requirement signature minimization: 'on', 'off', or 'verify'">;
 
+def requirement_machine_generic_signatures_EQ : Joined<["-"], "requirement-machine-generic-signatures=">,
+  Flags<[FrontendOption]>,
+  HelpText<"Control usage of experimental generic signature minimization: 'on', 'off', or 'verify'">;
+
 def experimental_hermetic_seal_at_link:
   Flag<["-"], "experimental-hermetic-seal-at-link">,
   Flags<[FrontendOption, HelpHidden]>,

lib/AST/ASTContext.cpp

@@ -2003,31 +2003,18 @@ GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
   return builder;
 }
 
-rewriting::RequirementMachine *
-ASTContext::getOrCreateRequirementMachine(CanGenericSignature sig) {
+rewriting::RewriteContext &
+ASTContext::getRewriteContext() {
   auto &rewriteCtx = getImpl().TheRewriteContext;
   if (!rewriteCtx)
     rewriteCtx.reset(new rewriting::RewriteContext(*this));
 
-  return rewriteCtx->getRequirementMachine(sig);
+  return *rewriteCtx;
 }
 
 bool ASTContext::isRecursivelyConstructingRequirementMachine(
       CanGenericSignature sig) {
-  auto &rewriteCtx = getImpl().TheRewriteContext;
-  if (!rewriteCtx)
-    return false;
-
-  return rewriteCtx->isRecursivelyConstructingRequirementMachine(sig);
-}
-
-rewriting::RequirementMachine *
-ASTContext::getOrCreateRequirementMachine(const ProtocolDecl *proto) {
-  auto &rewriteCtx = getImpl().TheRewriteContext;
-  if (!rewriteCtx)
-    rewriteCtx.reset(new rewriting::RewriteContext(*this));
-
-  return rewriteCtx->getRequirementMachine(proto);
+  return getRewriteContext().isRecursivelyConstructingRequirementMachine(sig);
 }
 
 Optional<llvm::TinyPtrVector<ValueDecl *>>

lib/AST/GenericSignature.cpp

@@ -199,7 +199,7 @@ GenericSignatureImpl::getRequirementMachine() const {
     return Machine;
 
   const_cast<GenericSignatureImpl *>(this)->Machine
-      = getASTContext().getOrCreateRequirementMachine(
+      = getASTContext().getRewriteContext().getRequirementMachine(
           getCanonicalSignature());
   return Machine;
 }

lib/AST/GenericSignatureBuilder.cpp

@@ -8559,24 +8559,62 @@ AbstractGenericSignatureRequest::evaluate(
         canSignatureResult.getInt());
   }
 
-  // Create a generic signature that will form the signature.
-  GenericSignatureBuilder builder(ctx);
-  if (baseSignature)
-    builder.addGenericSignature(baseSignature);
+  auto buildViaGSB = [&]() {
+    // Create a generic signature that will form the signature.
+    GenericSignatureBuilder builder(ctx);
+    if (baseSignature)
+      builder.addGenericSignature(baseSignature);
 
-  auto source =
-    GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
+    auto source =
+      GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
 
-  for (auto param : addedParameters)
-    builder.addGenericParameter(param);
+    for (auto param : addedParameters)
+      builder.addGenericParameter(param);
 
-  for (const auto &req : addedRequirements)
-    builder.addRequirement(req, source, nullptr);
+    for (const auto &req : addedRequirements)
+      builder.addRequirement(req, source, nullptr);
 
-  bool hadError = builder.hadAnyError();
-  auto result = std::move(builder).computeGenericSignature(
-      /*allowConcreteGenericParams=*/true);
-  return GenericSignatureWithError(result, hadError);
+    bool hadError = builder.hadAnyError();
+    auto result = std::move(builder).computeGenericSignature(
+        /*allowConcreteGenericParams=*/true);
+    return GenericSignatureWithError(result, hadError);
+  };
+
+  auto buildViaRQM = [&]() {
+    return evaluateOrDefault(
+        ctx.evaluator,
+        AbstractGenericSignatureRequestRQM{
+          baseSignature.getPointer(),
+          std::move(addedParameters),
+          std::move(addedRequirements)},
+        GenericSignatureWithError());
+  };
+
+  switch (ctx.LangOpts.RequirementMachineGenericSignatures) {
+  case RequirementMachineMode::Disabled:
+    return buildViaGSB();
+
+  case RequirementMachineMode::Enabled:
+    return buildViaRQM();
+
+  case RequirementMachineMode::Verify: {
+    auto rqmResult = buildViaRQM();
+    auto gsbResult = buildViaGSB();
+
+    if (!rqmResult.getPointer() && !gsbResult.getPointer())
+      return gsbResult;
+
+    if (!rqmResult.getPointer()->isEqual(gsbResult.getPointer())) {
+      llvm::errs() << "RequirementMachine generic signature minimization is broken:\n";
+      llvm::errs() << "RequirementMachine says:      " << rqmResult.getPointer() << "\n";
+      llvm::errs() << "GenericSignatureBuilder says: " << gsbResult.getPointer() << "\n";
+
+      abort();
+    }
+
+    return gsbResult;
+  }
+  }
 }
 
 GenericSignatureWithError

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -10,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//
 // This file implements the algorithm for computing a minimal set of rules from
 // a confluent rewrite system. A minimal set of rules is:
 //
@@ -76,7 +75,10 @@ using namespace rewriting;
 llvm::SmallVector<unsigned, 1>
 RewriteLoop::findRulesAppearingOnceInEmptyContext(
     const RewriteSystem &system) const {
+  // Rules appearing in empty context (possibly more than once).
   llvm::SmallDenseSet<unsigned, 2> rulesInEmptyContext;
+
+  // The number of times each rule appears (with or without context).
   llvm::SmallDenseMap<unsigned, unsigned, 2> ruleMultiplicity;
 
   RewritePathEvaluator evaluator(Basepoint);
@@ -100,6 +102,7 @@ RewriteLoop::findRulesAppearingOnceInEmptyContext(
     step.apply(evaluator, system);
   }
 
+  // Collect all rules that we saw exactly once in empty context.
   SmallVector<unsigned, 1> result;
   for (auto rule : rulesInEmptyContext) {
     auto found = ruleMultiplicity.find(rule);
@@ -759,8 +762,10 @@ void RewriteSystem::minimizeRewriteSystem() {
   // Now find a minimal set of generating conformances.
   //
   // FIXME: For now this just produces a set of redundant conformances, but
-  // it should actually compute the full generating conformance basis, since
-  // we want to use the same information for finding conformance access paths.
+  // it should actually output the canonical generating conformance equation
+  // for each non-generating conformance. We can then use information to
+  // compute conformance access paths, instead of the current "brute force"
+  // algorithm used for that purpose.
   llvm::DenseSet<unsigned> redundantConformances;
   computeGeneratingConformances(redundantConformances);
 
@@ -774,10 +779,14 @@ void RewriteSystem::minimizeRewriteSystem() {
 }
 
 /// Collect all non-permanent, non-redundant rules whose domain is equal to
-/// one of the protocols in \p proto. These rules form the requirement
-/// signatures of these protocols.
+/// one of the protocols in \p proto. In other words, the first symbol of the
+/// left hand side term is either a protocol symbol or associated type symbol
+/// whose protocol is in \p proto.
+///
+/// These rules form the requirement signatures of these protocols.
 llvm::DenseMap<const ProtocolDecl *, std::vector<unsigned>>
-RewriteSystem::getMinimizedRules(ArrayRef<const ProtocolDecl *> protos) {
+RewriteSystem::getMinimizedProtocolRules(
+    ArrayRef<const ProtocolDecl *> protos) const {
   assert(Minimized);
 
   llvm::DenseMap<const ProtocolDecl *, std::vector<unsigned>> rules;
@@ -801,6 +810,33 @@ RewriteSystem::getMinimizedRules(ArrayRef<const ProtocolDecl *> protos) {
   return rules;
 }
 
+/// Collect all non-permanent, non-redundant rules whose left hand side
+/// begins with a generic parameter symbol.
+///
+/// These rules form the top-level generic signature for this rewrite system.
+std::vector<unsigned>
+RewriteSystem::getMinimizedGenericSignatureRules() const {
+  assert(Minimized);
+
+  std::vector<unsigned> rules;
+  for (unsigned ruleID : indices(Rules)) {
+    const auto &rule = getRule(ruleID);
+
+    if (rule.isPermanent())
+      continue;
+
+    if (rule.isRedundant())
+      continue;
+
+    if (rule.getLHS()[0].getKind() != Symbol::Kind::GenericParam)
+      continue;
+
+    rules.push_back(ruleID);
+  }
+
+  return rules;
+}
+
 /// Verify that each loop begins and ends at its basepoint.
 void RewriteSystem::verifyRewriteLoops() const {
 #ifndef NDEBUG
@@ -831,6 +867,7 @@ void RewriteSystem::verifyRewriteLoops() const {
 /// since this suggests a misunderstanding on my part.
 void RewriteSystem::verifyRedundantConformances(
     llvm::DenseSet<unsigned> redundantConformances) const {
+#ifndef NDEBUG
   for (unsigned ruleID : redundantConformances) {
     const auto &rule = getRule(ruleID);
     assert(!rule.isPermanent() &&
@@ -848,11 +885,13 @@ void RewriteSystem::verifyRedundantConformances(
       abort();
     }
   }
+#endif
 }
 
 // Assert if homotopy reduction failed to eliminate a rewrite rule it was
 // supposed to delete.
 void RewriteSystem::verifyMinimizedRules() const {
+#ifndef NDEBUG
   for (const auto &rule : Rules) {
     // Note that sometimes permanent rules can be simplified, but they can never
     // be redundant.
@@ -890,4 +929,5 @@ void RewriteSystem::verifyMinimizedRules() const {
       abort();
     }
   }
+#endif
 }