[RequirementMachine] Factor the 'rules once in empty context' computation out

into a method on RewritePath.

Author: hborla

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -74,24 +74,14 @@ void RewriteLoop::recompute(const RewriteSystem &system) {
 
   ProjectionCount = 0;
   DecomposeCount = 0;
-
-  // 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;
+  Useful = false;
 
   RewritePathEvaluator evaluator(Basepoint);
-
   for (auto step : Path) {
     switch (step.Kind) {
-    case RewriteStep::Rule: {
-      if (!step.isInContext() && !evaluator.isInContext())
-        rulesInEmptyContext.insert(step.getRuleID());
-
-      ++ruleMultiplicity[step.getRuleID()];
+    case RewriteStep::Rule:
+      Useful |= (!step.isInContext() && !evaluator.isInContext());
       break;
-    }
 
     case RewriteStep::LeftConcreteProjection:
       ++ProjectionCount;
@@ -112,18 +102,7 @@ void RewriteLoop::recompute(const RewriteSystem &system) {
     evaluator.apply(step, system);
   }
 
-  Useful = !rulesInEmptyContext.empty();
-
-  RulesInEmptyContext.clear();
-
-  // Collect all rules that we saw exactly once in empty context.
-  for (auto rule : rulesInEmptyContext) {
-    auto found = ruleMultiplicity.find(rule);
-    assert(found != ruleMultiplicity.end());
-
-    if (found->second == 1)
-      RulesInEmptyContext.push_back(rule);
-  }
+  RulesInEmptyContext = Path.getRulesInEmptyContext(Basepoint, system);
 }
 
 /// A rewrite rule is redundant if it appears exactly once in a loop
@@ -227,48 +206,8 @@ void RewriteSystem::propagateRedundantRequirementIDs() {
     if (!requirementID.hasValue())
       continue;
 
-    // FIXME: This code is almost identical to `RewriteLoop::recompute`.
-
-    // 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> ruleFrequency;
-
-    RewritePathEvaluator evaluator(MutableTerm(rule.getLHS()));
-    for (auto step : rewritePath) {
-      switch (step.Kind) {
-      case RewriteStep::Rule: {
-        if (!step.isInContext() && !evaluator.isInContext())
-          rulesInEmptyContext.insert(step.getRuleID());
-
-        ++ruleFrequency[step.getRuleID()];
-        break;
-      }
-
-      case RewriteStep::LeftConcreteProjection:
-      case RewriteStep::Decompose:
-      case RewriteStep::PrefixSubstitutions:
-      case RewriteStep::Shift:
-      case RewriteStep::Relation:
-      case RewriteStep::DecomposeConcrete:
-      case RewriteStep::RightConcreteProjection:
-        break;
-      }
-
-      evaluator.apply(step, *this);
-    }
-
-    // Collect all rules that we saw exactly once in empty context.
-    SmallVector<unsigned, 1> rulesOnceInEmptyContext;
-    for (auto rule : rulesInEmptyContext) {
-      auto found = ruleFrequency.find(rule);
-      assert(found != ruleFrequency.end());
-
-      if (found->second == 1)
-        rulesOnceInEmptyContext.push_back(rule);
-    }
-
-    for (auto ruleID : rulesOnceInEmptyContext) {
+    MutableTerm lhs(rule.getLHS());
+    for (auto ruleID : rewritePath.getRulesInEmptyContext(lhs, *this)) {
       auto &replacement = Rules[ruleID];
       if (!replacement.isPermanent() &&
           !replacement.getRequirementID().hasValue()) {
@@ -489,6 +428,51 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
   return true;
 }
 
+SmallVector<unsigned, 1>
+RewritePath::getRulesInEmptyContext(const MutableTerm &term,
+                                    const RewriteSystem &system) {
+  // 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> ruleFrequency;
+
+  RewritePathEvaluator evaluator(term);
+  for (auto step : Steps) {
+    switch (step.Kind) {
+    case RewriteStep::Rule: {
+      if (!step.isInContext() && !evaluator.isInContext())
+        rulesInEmptyContext.insert(step.getRuleID());
+
+      ++ruleFrequency[step.getRuleID()];
+      break;
+    }
+
+    case RewriteStep::LeftConcreteProjection:
+    case RewriteStep::Decompose:
+    case RewriteStep::PrefixSubstitutions:
+    case RewriteStep::Shift:
+    case RewriteStep::Relation:
+    case RewriteStep::DecomposeConcrete:
+    case RewriteStep::RightConcreteProjection:
+      break;
+    }
+
+    evaluator.apply(step, system);
+  }
+
+  // Collect all rules that we saw exactly once in empty context.
+  SmallVector<unsigned, 1> rulesOnceInEmptyContext;
+  for (auto rule : rulesInEmptyContext) {
+    auto found = ruleFrequency.find(rule);
+    assert(found != ruleFrequency.end());
+
+    if (found->second == 1)
+      rulesOnceInEmptyContext.push_back(rule);
+  }
+
+  return rulesOnceInEmptyContext;
+}
+
 /// Find a rule to delete by looking through all loops for rewrite rules appearing
 /// once in empty context. Returns a pair consisting of a loop ID and a rule ID,
 /// otherwise returns None.

lib/AST/RequirementMachine/RewriteLoop.h

@@ -409,6 +409,9 @@ class RewritePath {
 
   bool replaceRuleWithPath(unsigned ruleID, const RewritePath &path);
 
+  SmallVector<unsigned, 1> getRulesInEmptyContext(const MutableTerm &term,
+                                                  const RewriteSystem &system);
+
   void invert();
 
   bool computeFreelyReducedForm();