RequirementMachine: Record those rewrite loops involving protocol typealiases

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -65,23 +65,30 @@
 using namespace swift;
 using namespace rewriting;
 
-/// Recompute Useful, RulesInEmptyContext, ProjectionCount and DecomposeCount
-/// if needed.
+/// Recompute various cached values if needed.
 void RewriteLoop::recompute(const RewriteSystem &system) {
   if (!Dirty)
     return;
   Dirty = 0;
 
+  Useful = 0;
   ProjectionCount = 0;
   DecomposeCount = 0;
-  Useful = false;
+  HasConcreteTypeAliasRule = 0;
 
   RewritePathEvaluator evaluator(Basepoint);
   for (auto step : Path) {
     switch (step.Kind) {
-    case RewriteStep::Rule:
+    case RewriteStep::Rule: {
       Useful |= (!step.isInContext() && !evaluator.isInContext());
+
+      const auto &rule = system.getRule(step.getRuleID());
+      if (rule.isProtocolTypeAliasRule() &&
+          rule.getLHS().size() == 3)
+        HasConcreteTypeAliasRule = 1;
+
       break;
+    }
 
     case RewriteStep::LeftConcreteProjection:
       ++ProjectionCount;
@@ -130,6 +137,14 @@ unsigned RewriteLoop::getDecomposeCount(
   return DecomposeCount;
 }
 
+/// Returns true if the loop contains at least one concrete protocol typealias rule,
+/// which have the form ([P].A.[concrete: C] => [P].A).
+bool RewriteLoop::hasConcreteTypeAliasRule(
+    const RewriteSystem &system) const {
+  const_cast<RewriteLoop *>(this)->recompute(system);
+  return HasConcreteTypeAliasRule;
+}
+
 /// The number of Decompose steps, used by the elimination order to prioritize
 /// loops that are not concrete simplifications.
 bool RewriteLoop::isUseful(

lib/AST/RequirementMachine/RewriteLoop.h

@@ -457,6 +457,9 @@ class RewriteLoop {
   /// Cached value for getDecomposeCount().
   unsigned DecomposeCount : 15;
 
+  /// Cached value for hasConcreteTypeAliasRule().
+  unsigned HasConcreteTypeAliasRule : 1;
+
   /// 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
@@ -478,6 +481,7 @@ class RewriteLoop {
     : Basepoint(basepoint), Path(path) {
     ProjectionCount = 0;
     DecomposeCount = 0;
+    HasConcreteTypeAliasRule = 0;
     Useful = 0;
     Deleted = 0;
 
@@ -509,6 +513,8 @@ class RewriteLoop {
 
   unsigned getDecomposeCount(const RewriteSystem &system) const;
 
+  bool hasConcreteTypeAliasRule(const RewriteSystem &system) const;
+
   void findProtocolConformanceRules(
       llvm::SmallDenseMap<const ProtocolDecl *,
                           ProtocolConformanceRules, 2> &result,

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -174,8 +174,13 @@ Optional<Identifier> Rule::isProtocolTypeAliasRule() const {
     //
     // We shouldn't have unresolved symbols on the right hand side;
     // they should have been simplified away.
-    if (RHS.containsUnresolvedSymbols())
-      return None;
+    if (RHS.containsUnresolvedSymbols()) {
+      if (RHS.size() != 2 ||
+          RHS[0] != LHS[0] ||
+          RHS[1].getKind() != Symbol::Kind::Name) {
+        return None;
+      }
+    }
   } else {
     // This is the case where the underlying type is concrete.
     assert(LHS.size() == 3);