RequirementMachine: Relax criterion for deleting a useless loop

Distinguish a loop with elimination candidates, which are rules
appearing in empty context and exactly once, from a useful loop,
which contains at least one rule in empty context (but the same
rule might appear more than once).

Normalizing a useful loop might produce a loop with elimination
candidates, but normalizing a useless loop never does.

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -64,7 +64,8 @@
 using namespace swift;
 using namespace rewriting;
 
-/// Recompute RulesInEmptyContext and DecomposeCount if needed.
+/// Recompute Useful, RulesInEmptyContext, ProjectionCount and DecomposeCount
+/// if needed.
 void RewriteLoop::recompute(const RewriteSystem &system) {
   if (!Dirty)
     return;
@@ -110,6 +111,8 @@ 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.
@@ -147,6 +150,14 @@ unsigned RewriteLoop::getDecomposeCount(
   return DecomposeCount;
 }
 
+/// The number of Decompose steps, used by the elimination order to prioritize
+/// loops that are not concrete simplifications.
+bool RewriteLoop::isUseful(
+    const RewriteSystem &system) const {
+  const_cast<RewriteLoop *>(this)->recompute(system);
+  return Useful;
+}
+
 /// 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.
@@ -419,22 +430,21 @@ findRuleToDelete(llvm::function_ref<bool(unsigned)> isRedundantRuleFn) {
     if (loop.isDeleted())
       continue;
 
-    bool foundAny = false;
-    for (unsigned ruleID : loop.findRulesAppearingOnceInEmptyContext(*this)) {
-      redundancyCandidates.emplace_back(loopID, ruleID);
-      foundAny = true;
-    }
-
     // Delete loops that don't contain any rewrite rules in empty context,
-    // since such loops do not give us useful information.
-    if (!foundAny) {
+    // since such loops do not yield any elimination candidates.
+    if (!loop.isUseful(*this)) {
       if (Debug.contains(DebugFlags::HomotopyReduction)) {
         llvm::dbgs() << "** Deleting useless loop #" << loopID << ": ";
         loop.dump(llvm::dbgs(), *this);
         llvm::dbgs() << "\n";
       }
 
       loop.markDeleted();
+      continue;
+    }
+
+    for (unsigned ruleID : loop.findRulesAppearingOnceInEmptyContext(*this)) {
+      redundancyCandidates.emplace_back(loopID, ruleID);
     }
   }
 

lib/AST/RequirementMachine/RewriteLoop.h

@@ -454,12 +454,18 @@ class RewriteLoop {
   /// Cached value for getDecomposeCount().
   unsigned DecomposeCount : 15;
 
-  /// 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.
+  /// A useful loop contains at least one rule in empty context, even if that
+  /// rule appears multiple times or also in non-empty context. The only loops
+  /// that are elimination candidates contain a rule in empty context *exactly
+  /// once*. A useful loop can become an elimination candidate after
+  /// normalization.
+  unsigned Useful : 1;
+
+  /// Loops are deleted once they are no longer useful, as defined above.
   unsigned Deleted : 1;
 
-  /// If true, RulesInEmptyContext should be recomputed.
+  /// If true, Useful, RulesInEmptyContext, ProjectionCount, and DecomposeCount
+  /// should be recomputed.
   unsigned Dirty : 1;
 
   void recompute(const RewriteSystem &system);
@@ -469,11 +475,11 @@ class RewriteLoop {
     : Basepoint(basepoint), Path(path) {
     ProjectionCount = 0;
     DecomposeCount = 0;
-
+    Useful = 0;
     Deleted = 0;
 
-    // Initially, RulesInEmptyContext and ProjectionCount are not valid because
-    // they have not been computed yet.
+    // Initially, cached values are not valid because they have not been
+    // computed yet.
     Dirty = 1;
   }
 
@@ -491,7 +497,7 @@ class RewriteLoop {
     Dirty = 1;
   }
 
-  bool isInContext(const RewriteSystem &system) const;
+  bool isUseful(const RewriteSystem &system) const;
 
   ArrayRef<unsigned>
   findRulesAppearingOnceInEmptyContext(const RewriteSystem &system) const;