RequirementMachine: Preliminary refactoring in preparation for computing top-level generic signatures

Author: slavapestov

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 *),

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,

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -779,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;
@@ -806,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

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -66,7 +66,7 @@ struct RewriteSystemBuilder {
 
   RewriteSystemBuilder(RewriteContext &ctx, bool dump)
     : Context(ctx), Dump(dump) {}
-  void addGenericSignature(CanGenericSignature sig);
+  void addRequirements(ArrayRef<Requirement> requirements);
   void addProtocols(ArrayRef<const ProtocolDecl *> proto);
   void addProtocol(const ProtocolDecl *proto,
                    bool initialComponent);
@@ -108,19 +108,18 @@ RewriteSystemBuilder::getConcreteSubstitutionSchema(CanType concreteType,
   }));
 }
 
-void RewriteSystemBuilder::addGenericSignature(CanGenericSignature sig) {
-  // Collect all protocols transitively referenced from the generic signature's
-  // requirements.
-  for (auto req : sig.getRequirements()) {
+void RewriteSystemBuilder::addRequirements(ArrayRef<Requirement> requirements) {
+  // Collect all protocols transitively referenced from these requirements.
+  for (auto req : requirements) {
     if (req.getKind() == RequirementKind::Conformance) {
       addProtocol(req.getProtocolDecl(), /*initialComponent=*/false);
     }
   }
 
   processProtocolDependencies();
 
-  // Add rewrite rules for all requirements in the top-level signature.
-  for (const auto &req : sig.getRequirements())
+  // Add rewrite rules for all top-level requirements.
+  for (const auto &req : requirements)
     addRequirement(req, /*proto=*/nullptr);
 }
 
@@ -350,7 +349,7 @@ void RequirementMachine::verify(const MutableTerm &term) const {
   // generic parameter.
   if (term.begin()->getKind() == Symbol::Kind::GenericParam) {
     auto *genericParam = term.begin()->getGenericParam();
-    auto genericParams = Sig.getGenericParams();
+    TypeArrayView<GenericTypeParamType> genericParams = getGenericParams();
     auto found = std::find(genericParams.begin(),
                            genericParams.end(),
                            genericParam);
@@ -428,8 +427,13 @@ void RequirementMachine::dump(llvm::raw_ostream &out) const {
   out << "Requirement machine for ";
   if (Sig)
     out << Sig;
-  else {
-    out << "[";
+  else if (!Params.empty()) {
+    out << "fresh signature ";
+    for (auto paramTy : Params)
+      out << " " << Type(paramTy);
+  } else {
+    assert(!Protos.empty());
+    out << "protocols [";
     for (auto *proto : Protos) {
       out << " " << proto->getName();
     }
@@ -467,6 +471,8 @@ RequirementMachine::~RequirementMachine() {}
 /// performed on this requirement machine.
 void RequirementMachine::initWithGenericSignature(CanGenericSignature sig) {
   Sig = sig;
+  Params.append(sig.getGenericParams().begin(),
+                sig.getGenericParams().end());
 
   PrettyStackTraceGenericSignature debugStack("building rewrite system for", sig);
 
@@ -485,7 +491,7 @@ void RequirementMachine::initWithGenericSignature(CanGenericSignature sig) {
   // Collect the top-level requirements, and all transtively-referenced
   // protocol requirement signatures.
   RewriteSystemBuilder builder(Context, Dump);
-  builder.addGenericSignature(sig);
+  builder.addRequirements(sig.getRequirements());
 
   // Add the initial set of rewrite rules to the rewrite system.
   System.initialize(/*recordLoops=*/false,

lib/AST/RequirementMachine/RequirementMachine.h

@@ -47,6 +47,7 @@ class RequirementMachine final {
   friend class swift::rewriting::RewriteContext;
 
   CanGenericSignature Sig;
+  SmallVector<Type, 2> Params;
   ArrayRef<const ProtocolDecl *> Protos;
 
   RewriteContext &Context;
@@ -87,8 +88,14 @@ class RequirementMachine final {
 
   MutableTerm getLongestValidPrefix(const MutableTerm &term) const;
 
-  std::vector<Requirement> buildRequirementSignature(
-    ArrayRef<unsigned> rules, const ProtocolDecl *proto) const;
+  std::vector<Requirement> buildRequirementsFromRules(
+    ArrayRef<unsigned> rules,
+    TypeArrayView<GenericTypeParamType> genericParams) const;
+
+  TypeArrayView<GenericTypeParamType> getGenericParams() const {
+    return TypeArrayView<GenericTypeParamType>(
+      ArrayRef<Type>(Params));
+  }
 
 public:
   ~RequirementMachine();
@@ -116,7 +123,9 @@ class RequirementMachine final {
   TypeDecl *lookupNestedType(Type depType, Identifier name) const;
 
   llvm::DenseMap<const ProtocolDecl *, std::vector<Requirement>>
-  computeMinimalRequirements();
+  computeMinimalProtocolRequirements();
+
+  std::vector<Requirement> computeMinimalGenericSignatureRequirements();
 
   void verify(const MutableTerm &term) const;
   void dump(llvm::raw_ostream &out) const;

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -88,17 +88,16 @@ void ConnectedComponent::buildRequirements(Type subjectType,
 
 }  // end namespace
 
-/// Convert a list of non-permanent, non-redundant rewrite rules into a minimal
-/// protocol requirement signature for \p proto. The requirements are sorted in
-/// canonical order, and same-type requirements are canonicalized.
+/// Convert a list of non-permanent, non-redundant rewrite rules into a list of
+/// requirements sorted in canonical order. The \p genericParams are used to
+/// produce sugared types.
 std::vector<Requirement>
-RequirementMachine::buildRequirementSignature(ArrayRef<unsigned> rules,
-                                              const ProtocolDecl *proto) const {
+RequirementMachine::buildRequirementsFromRules(
+    ArrayRef<unsigned> rules,
+    TypeArrayView<GenericTypeParamType> genericParams) const {
   std::vector<Requirement> reqs;
   llvm::SmallDenseMap<TypeBase *, ConnectedComponent> sameTypeReqs;
 
-  auto genericParams = proto->getGenericSignature().getGenericParams();
-
   // Convert a rewrite rule into a requirement.
   auto createRequirementFromRule = [&](const Rule &rule) {
     if (auto prop = rule.isPropertyRule()) {
@@ -196,23 +195,29 @@ RequirementMachine::buildRequirementSignature(ArrayRef<unsigned> rules,
 /// Builds the requirement signatures for each protocol in this strongly
 /// connected component.
 llvm::DenseMap<const ProtocolDecl *, std::vector<Requirement>>
-RequirementMachine::computeMinimalRequirements() {
-  assert(Protos.size() > 0);
+RequirementMachine::computeMinimalProtocolRequirements() {
+  assert(Protos.size() > 0 &&
+         "Not a protocol connected component rewrite system");
+  assert(Params.empty() &&
+         "Not a protocol connected component rewrite system");
+
   System.minimizeRewriteSystem();
 
   if (Dump) {
     llvm::dbgs() << "Minimized rewrite system:\n";
     dump(llvm::dbgs());
   }
 
-  auto rules = System.getMinimizedRules(Protos);
+  auto rules = System.getMinimizedProtocolRules(Protos);
 
   // Note that we build 'result' by iterating over 'Protos' rather than
   // 'rules'; this is intentional, so that even if a protocol has no
   // rules, we still end up creating an entry for it in 'result'.
   llvm::DenseMap<const ProtocolDecl *, std::vector<Requirement>> result;
-  for (const auto *proto : Protos)
-    result[proto] = buildRequirementSignature(rules[proto], proto);
+  for (const auto *proto : Protos) {
+    auto genericParams = proto->getGenericSignature().getGenericParams();
+    result[proto] = buildRequirementsFromRules(rules[proto], genericParams);
+  }
 
   return result;
 }
@@ -229,7 +234,7 @@ RequirementSignatureRequestRQM::evaluate(Evaluator &evaluator,
   // 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();
+  auto requirements = machine->computeMinimalProtocolRequirements();
 
   bool debug = machine->getDebugOptions().contains(DebugFlags::Minimization);
 
@@ -269,3 +274,22 @@ RequirementSignatureRequestRQM::evaluate(Evaluator &evaluator,
   // 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() {
+  assert(Protos.empty() &&
+         "Not a top-level generic signature rewrite system");
+  assert(!Params.empty() &&
+         "Not a from-source top-level generic signature rewrite system");
+
+  System.minimizeRewriteSystem();
+
+  if (Dump) {
+    llvm::dbgs() << "Minimized rewrite system:\n";
+    dump(llvm::dbgs());
+  }
+
+  auto rules = System.getMinimizedGenericSignatureRules();
+  return buildRequirementsFromRules(rules, getGenericParams());
+}

lib/AST/RequirementMachine/RewriteSystem.h

@@ -340,7 +340,9 @@ class RewriteSystem final {
   void minimizeRewriteSystem();
 
   llvm::DenseMap<const ProtocolDecl *, std::vector<unsigned>>
-  getMinimizedRules(ArrayRef<const ProtocolDecl *> protos);
+  getMinimizedProtocolRules(ArrayRef<const ProtocolDecl *> protos) const;
+
+  std::vector<unsigned> getMinimizedGenericSignatureRules() const;
 
   void verifyRewriteLoops() const;