RequirementMachine: Rename RewriteSystemBuilder::AssociatedTypeRules => PermanentRules

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -49,7 +49,15 @@ struct RewriteSystemBuilder {
   llvm::DenseMap<const ProtocolDecl *, bool> ProtocolMap;
   std::vector<const ProtocolDecl *> Protocols;
 
-  std::vector<std::pair<MutableTerm, MutableTerm>> AssociatedTypeRules;
+  /// New rules to add which will be marked 'permanent'. These are rules for
+  /// introducing associated types, and relationships between layout,
+  /// superclass and concrete type symbols. They are not eliminated by
+  /// homotopy reduction, since they are always added when the rewrite system
+  /// is built.
+  std::vector<std::pair<MutableTerm, MutableTerm>> PermanentRules;
+
+  /// New rules derived from requirements written by the user, which can be
+  /// eliminated by homotopy reduction.
   std::vector<std::pair<MutableTerm, MutableTerm>> RequirementRules;
 
   CanType getConcreteSubstitutionSchema(CanType concreteType,
@@ -141,7 +149,7 @@ void RewriteSystemBuilder::addAssociatedType(const AssociatedTypeDecl *type,
   MutableTerm rhs;
   rhs.add(Symbol::forAssociatedType(proto, type->getName(), Context));
 
-  AssociatedTypeRules.emplace_back(lhs, rhs);
+  PermanentRules.emplace_back(lhs, rhs);
 }
 
 /// Lowers a generic requirement to a rewrite rule.
@@ -283,7 +291,7 @@ void RewriteSystemBuilder::processProtocolDependencies() {
     MutableTerm rhs;
     rhs.add(Symbol::forProtocol(proto, Context));
 
-    AssociatedTypeRules.emplace_back(lhs, rhs);
+    PermanentRules.emplace_back(lhs, rhs);
 
     for (auto *assocType : proto->getAssociatedTypeMembers())
       addAssociatedType(assocType, proto);
@@ -457,10 +465,9 @@ void RequirementMachine::initWithGenericSignature(CanGenericSignature sig) {
   RewriteSystemBuilder builder(Context, Dump);
   builder.addGenericSignature(sig);
 
-  // Add the initial set of rewrite rules to the rewrite system, also
-  // providing the protocol graph to use for the linear order on terms.
+  // Add the initial set of rewrite rules to the rewrite system.
   System.initialize(/*recordLoops=*/false,
-                    std::move(builder.AssociatedTypeRules),
+                    std::move(builder.PermanentRules),
                     std::move(builder.RequirementRules));
 
   computeCompletion(RewriteSystem::DisallowInvalidRequirements);
@@ -498,10 +505,9 @@ void RequirementMachine::initWithProtocols(ArrayRef<const ProtocolDecl *> protos
   RewriteSystemBuilder builder(Context, Dump);
   builder.addProtocols(protos);
 
-  // Add the initial set of rewrite rules to the rewrite system, also
-  // providing the protocol graph to use for the linear order on terms.
+  // Add the initial set of rewrite rules to the rewrite system.
   System.initialize(/*recordLoops=*/true,
-                    std::move(builder.AssociatedTypeRules),
+                    std::move(builder.PermanentRules),
                     std::move(builder.RequirementRules));
 
   // FIXME: Only if the protocols were written in source, though.

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -122,18 +122,15 @@ RewriteSystem::~RewriteSystem() {
 
 void RewriteSystem::initialize(
     bool recordLoops,
-    std::vector<std::pair<MutableTerm, MutableTerm>> &&associatedTypeRules,
+    std::vector<std::pair<MutableTerm, MutableTerm>> &&permanentRules,
     std::vector<std::pair<MutableTerm, MutableTerm>> &&requirementRules) {
   assert(!Initialized);
   Initialized = 1;
 
   RecordLoops = recordLoops;
 
-  for (const auto &rule : associatedTypeRules) {
-    bool added = addRule(rule.first, rule.second);
-    if (added)
-      Rules.back().markPermanent();
-  }
+  for (const auto &rule : permanentRules)
+    addPermanentRule(rule.first, rule.second);
 
   for (const auto &rule : requirementRules)
     addRule(rule.first, rule.second);
@@ -406,6 +403,15 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs,
   return true;
 }
 
+/// Add a new rule, marking it permanent.
+bool RewriteSystem::addPermanentRule(MutableTerm lhs, MutableTerm rhs) {
+  bool added = addRule(std::move(lhs), std::move(rhs));
+  if (added)
+    Rules.back().markPermanent();
+
+  return added;
+}
+
 /// Delete any rules whose left hand sides can be reduced by other rules,
 /// and reduce the right hand sides of all remaining rules as much as
 /// possible.

lib/AST/RequirementMachine/RewriteSystem.h

@@ -230,7 +230,7 @@ class RewriteSystem final {
   RewriteContext &getRewriteContext() const { return Context; }
 
   void initialize(bool recordLoops,
-                  std::vector<std::pair<MutableTerm, MutableTerm>> &&assocaitedTypeRules,
+                  std::vector<std::pair<MutableTerm, MutableTerm>> &&permanentRules,
                   std::vector<std::pair<MutableTerm, MutableTerm>> &&requirementRules);
 
   unsigned getRuleID(const Rule &rule) const {
@@ -253,6 +253,8 @@ class RewriteSystem final {
   bool addRule(MutableTerm lhs, MutableTerm rhs,
                const RewritePath *path=nullptr);
 
+  bool addPermanentRule(MutableTerm lhs, MutableTerm rhs);
+
   bool simplify(MutableTerm &term, RewritePath *path=nullptr) const;
 
   void simplifySubstitutions(MutableTerm &term, RewritePath &path) const;