RequirementMachine: Introduce RewriteLoop::getProjectionCount()

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -63,18 +63,13 @@
 using namespace swift;
 using namespace rewriting;
 
-/// A rewrite rule is redundant if it appears exactly once in a loop
-/// without context.
-///
-/// This method will cache the result; markDirty() must be called after
-/// the underlying rewrite path is modified to invalidate the cached
-/// result.
-ArrayRef<unsigned>
-RewriteLoop::findRulesAppearingOnceInEmptyContext(
-    const RewriteSystem &system) const {
-  // If we're allowed to use the cached result, return that.
+/// Recompute RulesInEmptyContext and DecomposeCount if needed.
+void RewriteLoop::recompute(const RewriteSystem &system) {
   if (!Dirty)
-    return RulesInEmptyContext;
+    return;
+  Dirty = 0;
+
+  ProjectionCount = 0;
 
   // Rules appearing in empty context (possibly more than once).
   llvm::SmallDenseSet<unsigned, 2> rulesInEmptyContext;
@@ -94,36 +89,51 @@ RewriteLoop::findRulesAppearingOnceInEmptyContext(
       break;
     }
 
+    case RewriteStep::LeftConcreteProjection:
+      ++ProjectionCount;
+      break;
+
     case RewriteStep::PrefixSubstitutions:
     case RewriteStep::Shift:
     case RewriteStep::Decompose:
     case RewriteStep::Relation:
     case RewriteStep::DecomposeConcrete:
-    case RewriteStep::LeftConcreteProjection:
     case RewriteStep::RightConcreteProjection:
       break;
     }
 
     evaluator.apply(step, system);
   }
 
-  auto *mutThis = const_cast<RewriteLoop *>(this);
-  mutThis->RulesInEmptyContext.clear();
+  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)
-      mutThis->RulesInEmptyContext.push_back(rule);
+      RulesInEmptyContext.push_back(rule);
   }
+}
 
-  // Cache the result for later.
-  mutThis->Dirty = 0;
+/// A rewrite rule is redundant if it appears exactly once in a loop
+/// without context.
+ArrayRef<unsigned>
+RewriteLoop::findRulesAppearingOnceInEmptyContext(
+    const RewriteSystem &system) const {
+  const_cast<RewriteLoop *>(this)->recompute(system);
   return RulesInEmptyContext;
 }
 
+/// The number of LeftConcreteProjection steps, used by the elimination order to
+/// prioritize loops that are not concrete unification projections.
+unsigned RewriteLoop::getProjectionCount(
+    const RewriteSystem &system) const {
+  const_cast<RewriteLoop *>(this)->recompute(system);
+  return ProjectionCount;
+}
+
 /// If a rewrite loop contains an explicit rule in empty context, propagate the
 /// explicit bit to all other rules appearing in empty context within the same
 /// loop.

lib/AST/RequirementMachine/RewriteLoop.h

@@ -433,21 +433,31 @@ class RewriteLoop {
   RewritePath Path;
 
 private:
-  unsigned Deleted : 1;
-
   /// Cached value for findRulesAppearingOnceInEmptyContext().
   SmallVector<unsigned, 1> RulesInEmptyContext;
 
+  /// Cached value for getProjectionCount().
+  unsigned ProjectionCount : 30;
+
+  /// Loops are deleted once they no longer contain rules in empty context,
+  /// since at that point they don't participate in minimization and do not
+  /// need to be considered.
+  unsigned Deleted : 1;
+
   /// If true, RulesInEmptyContext should be recomputed.
   unsigned Dirty : 1;
 
+  void recompute(const RewriteSystem &system);
+
 public:
   RewriteLoop(MutableTerm basepoint, RewritePath path)
     : Basepoint(basepoint), Path(path) {
+    ProjectionCount = 0;
+
     Deleted = 0;
 
-    // Initially, the RulesInEmptyContext vector is not valid because
-    // it has not been computed yet.
+    // Initially, RulesInEmptyContext and ProjectionCount are not valid because
+    // they have not been computed yet.
     Dirty = 1;
   }
 
@@ -470,6 +480,8 @@ class RewriteLoop {
   ArrayRef<unsigned>
   findRulesAppearingOnceInEmptyContext(const RewriteSystem &system) const;
 
+  unsigned getProjectionCount(const RewriteSystem &system) const;
+
   void findProtocolConformanceRules(
       llvm::SmallDenseMap<const ProtocolDecl *,
                           ProtocolConformanceRules, 2> &result,