RequirementMachine: Replace RewriteStep::AbstractTypeWitness with relations

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -100,7 +100,6 @@ RewriteLoop::findRulesAppearingOnceInEmptyContext(
     case RewriteStep::Relation:
     case RewriteStep::ConcreteTypeWitness:
     case RewriteStep::SameTypeWitness:
-    case RewriteStep::AbstractTypeWitness:
       break;
     }
 
@@ -222,7 +221,6 @@ RewritePath RewritePath::splitCycleAtRule(unsigned ruleID) const {
     case RewriteStep::Relation:
     case RewriteStep::ConcreteTypeWitness:
     case RewriteStep::SameTypeWitness:
-    case RewriteStep::AbstractTypeWitness:
       break;
     }
 
@@ -322,7 +320,6 @@ bool RewritePath::replaceRuleWithPath(unsigned ruleID,
     case RewriteStep::Relation:
     case RewriteStep::ConcreteTypeWitness:
     case RewriteStep::SameTypeWitness:
-    case RewriteStep::AbstractTypeWitness:
       newSteps.push_back(step);
       break;
     }

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -140,7 +140,6 @@ void RewriteLoop::findProtocolConformanceRules(
       case RewriteStep::Relation:
       case RewriteStep::ConcreteTypeWitness:
       case RewriteStep::SameTypeWitness:
-      case RewriteStep::AbstractTypeWitness:
         break;
       }
     }

lib/AST/RequirementMachine/PropertyUnification.cpp

@@ -837,13 +837,15 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
     //
     // Where S[n] is the nth substitution term.
 
-    auto result = Context.getRelativeTermForType(typeWitness, substitutions);
+    auto result = Context.getRelativeTermForType(
+        typeWitness, substitutions);
 
-    RewriteSystem::TypeWitness witness(Term::get(subjectType, Context),
-                                       Term::get(result, Context));
-    unsigned witnessID = System.recordTypeWitness(witness);
-    path.add(RewriteStep::forAbstractTypeWitness(
-        witnessID, /*inverse=*/false));
+    unsigned relationID = System.recordRelation(
+        Term::get(result, Context),
+        Term::get(subjectType, Context));
+    path.add(RewriteStep::forRelation(
+        /*startOffset=*/0, relationID,
+        /*inverse=*/false));
 
     return result;
   }
@@ -862,11 +864,11 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
             props->getConcreteType() == typeWitness) {
           auto result = props->getKey();
 
-          RewriteSystem::TypeWitness witness(Term::get(subjectType, Context),
-                                             result);
-          unsigned witnessID = System.recordTypeWitness(witness);
-          path.add(RewriteStep::forAbstractTypeWitness(
-              witnessID, /*inverse=*/false));
+          unsigned relationID = System.recordRelation(
+              result, Term::get(subjectType, Context));
+          path.add(RewriteStep::forRelation(
+              /*startOffset=*/0, relationID,
+              /*inverse=*/false));
 
           if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
              llvm::dbgs() << "^^ Type witness can re-use property bag of "

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -93,14 +93,6 @@ void RewriteStep::dump(llvm::raw_ostream &out,
                     : "SameTypeWitness");
     break;
   }
-  case AbstractTypeWitness: {
-    evaluator.applyAbstractTypeWitness(*this, system);
-
-    out << (Inverse ? "AbstractTypeWitness⁻¹"
-                    : "AbstractTypeWitness");
-    break;
-  }
-
   }
 }
 
@@ -527,42 +519,6 @@ void RewritePathEvaluator::applySameTypeWitness(const RewriteStep &step,
   }
 }
 
-void
-RewritePathEvaluator::applyAbstractTypeWitness(const RewriteStep &step,
-                                               const RewriteSystem &system) {
-  checkPrimary();
-  auto &term = Primary.back();
-
-  const auto &witness = system.getTypeWitness(step.Arg);
-  auto fail = [&]() {
-    llvm::errs() << "Bad abstract type witness term:\n";
-    llvm::errs() << term << "\n\n";
-    witness.dump(llvm::errs());
-    abort();
-  };
-
-  auto typeWitness = witness.getAbstractType();
-
-  Term origTerm = (step.Inverse ? witness.LHS : typeWitness);
-  Term substTerm = (step.Inverse ? typeWitness : witness.LHS);
-
-  if (term.size() != step.StartOffset + origTerm.size() + step.EndOffset) {
-    fail();
-  }
-
-  if (!std::equal(origTerm.begin(),
-                  origTerm.end(),
-                  term.begin() + step.StartOffset)) {
-    fail();
-  }
-
-  MutableTerm newTerm(term.begin(), term.begin() + step.StartOffset);
-  newTerm.append(substTerm);
-  newTerm.append(term.end() - step.EndOffset, term.end());
-
-  term = newTerm;
-}
-
 void RewritePathEvaluator::apply(const RewriteStep &step,
                                  const RewriteSystem &system) {
   switch (step.Kind) {
@@ -593,9 +549,5 @@ void RewritePathEvaluator::apply(const RewriteStep &step,
   case RewriteStep::SameTypeWitness:
     applySameTypeWitness(step, system);
     break;
-
-  case RewriteStep::AbstractTypeWitness:
-    applyAbstractTypeWitness(step, system);
-    break;
   }
 }

lib/AST/RequirementMachine/RewriteLoop.h

@@ -119,15 +119,6 @@ struct RewriteStep {
     ///
     /// The Arg field stores the result of RewriteSystem::recordTypeWitness().
     SameTypeWitness,
-
-    /// If not inverted: replaces the abstract type witness term with the
-    /// subject type term.
-    ///
-    /// If inverted: replaces the subject type term with the abstract type
-    /// term.
-    ///
-    /// The Arg field stores the result of RewriteSystem::recordTypeWitness().
-    AbstractTypeWitness,
   };
 
   /// The rewrite step kind.
@@ -203,11 +194,6 @@ struct RewriteStep {
                        /*arg=*/witnessID, inverse);
   }
 
-  static RewriteStep forAbstractTypeWitness(unsigned witnessID, bool inverse) {
-    return RewriteStep(AbstractTypeWitness, /*startOffset=*/0, /*endOffset=*/0,
-                       /*arg=*/witnessID, inverse);
-  }
-
   bool isInContext() const {
     return StartOffset > 0 || EndOffset > 0;
   }
@@ -406,9 +392,6 @@ struct RewritePathEvaluator {
   void applySameTypeWitness(const RewriteStep &step,
                             const RewriteSystem &system);
 
-  void applyAbstractTypeWitness(const RewriteStep &step,
-                                const RewriteSystem &system);
-
   void dump(llvm::raw_ostream &out) const;
 };