RequirementMachine: Temporarily disable associated type merging when minimizing protocol signatures

Also while plumbing this through, don't record homotopy generators
unless we're minimizing a protocol signature, since they're not
used for anything else yet.

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -409,7 +409,8 @@ void RequirementMachine::initWithGenericSignature(CanGenericSignature sig) {
 
   // Add the initial set of rewrite rules to the rewrite system, also
   // providing the protocol graph to use for the linear order on terms.
-  System.initialize(std::move(builder.AssociatedTypeRules),
+  System.initialize(/*recordHomotopyGenerators=*/false,
+                    std::move(builder.AssociatedTypeRules),
                     std::move(builder.RequirementRules),
                     std::move(builder.Protocols));
 
@@ -450,7 +451,8 @@ void RequirementMachine::initWithProtocols(ArrayRef<const ProtocolDecl *> protos
 
   // Add the initial set of rewrite rules to the rewrite system, also
   // providing the protocol graph to use for the linear order on terms.
-  System.initialize(std::move(builder.AssociatedTypeRules),
+  System.initialize(/*recordHomotopyGenerators=*/true,
+                    std::move(builder.AssociatedTypeRules),
                     std::move(builder.RequirementRules),
                     std::move(builder.Protocols));
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -88,6 +88,7 @@ RewriteSystem::RewriteSystem(RewriteContext &ctx)
   Initialized = 0;
   Complete = 0;
   Minimized = 0;
+  RecordHomotopyGenerators = 0;
 }
 
 RewriteSystem::~RewriteSystem() {
@@ -96,12 +97,14 @@ RewriteSystem::~RewriteSystem() {
 }
 
 void RewriteSystem::initialize(
+    bool recordHomotopyGenerators,
     std::vector<std::pair<MutableTerm, MutableTerm>> &&associatedTypeRules,
     std::vector<std::pair<MutableTerm, MutableTerm>> &&requirementRules,
     ProtocolGraph &&graph) {
   assert(!Initialized);
   Initialized = 1;
 
+  RecordHomotopyGenerators = recordHomotopyGenerators;
   Protos = graph;
 
   for (const auto &rule : associatedTypeRules) {
@@ -170,7 +173,7 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs,
     if (path) {
       // We already have a loop, since the simplified lhs is identical to the
       // simplified rhs.
-      HomotopyGenerators.emplace_back(lhs, loop);
+      recordHomotopyGenerator(lhs, loop);
 
       if (Debug.contains(DebugFlags::Add)) {
         llvm::dbgs() << "## Recorded trivial loop at " << lhs << ": ";
@@ -206,7 +209,7 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs,
     // add a rewrite step applying the new rule in reverse to close the loop.
     loop.add(RewriteStep::forRewriteRule(/*startOffset=*/0, /*endOffset=*/0,
                                          newRuleID, /*inverse=*/true));
-    HomotopyGenerators.emplace_back(lhs, loop);
+    recordHomotopyGenerator(lhs, loop);
 
     if (Debug.contains(DebugFlags::Add)) {
       llvm::dbgs() << "## Recorded non-trivial loop at " << lhs << ": ";
@@ -376,7 +379,7 @@ void RewriteSystem::simplifyRewriteSystem() {
     loop.add(RewriteStep::forRewriteRule(/*startOffset=*/0, /*endOffset=*/0,
                                          newRuleID, /*inverse=*/true));
 
-    HomotopyGenerators.emplace_back(MutableTerm(lhs), loop);
+    recordHomotopyGenerator(MutableTerm(lhs), loop);
 
     if (Debug.contains(DebugFlags::Completion)) {
       llvm::dbgs() << "$ Right hand side simplification recorded a loop: ";

lib/AST/RequirementMachine/RewriteSystem.h

@@ -379,6 +379,9 @@ class RewriteSystem final {
   /// Whether we've minimized the rewrite system.
   unsigned Minimized : 1;
 
+  /// If set, record homotopy generators in the completion procedure.
+  unsigned RecordHomotopyGenerators : 1;
+
 public:
   explicit RewriteSystem(RewriteContext &ctx);
   ~RewriteSystem();
@@ -394,7 +397,8 @@ class RewriteSystem final {
   /// Return the object recording information about known protocols.
   const ProtocolGraph &getProtocols() const { return Protos; }
 
-  void initialize(std::vector<std::pair<MutableTerm, MutableTerm>> &&assocaitedTypeRules,
+  void initialize(bool recordHomotopyGenerators,
+                  std::vector<std::pair<MutableTerm, MutableTerm>> &&assocaitedTypeRules,
                   std::vector<std::pair<MutableTerm, MutableTerm>> &&requirementRules,
                   ProtocolGraph &&protos);
 
@@ -452,6 +456,21 @@ class RewriteSystem final {
   void verifyRewriteRules(ValidityPolicy policy) const;
 
 private:
+  void recordHomotopyGenerator(HomotopyGenerator loop) {
+    if (!RecordHomotopyGenerators)
+      return;
+
+    HomotopyGenerators.push_back(loop);
+  }
+
+  void recordHomotopyGenerator(MutableTerm basepoint,
+                               RewritePath path) {
+    if (!RecordHomotopyGenerators)
+      return;
+
+    HomotopyGenerators.emplace_back(basepoint, path);
+  }
+
   bool
   computeCriticalPair(
       ArrayRef<Symbol>::const_iterator from,

lib/AST/RequirementMachine/RewriteSystemCompletion.cpp

@@ -291,6 +291,10 @@ void RewriteSystem::processMergedAssociatedTypes() {
 /// If so, record this rule for later. We'll try to merge the associated
 /// types in RewriteSystem::processMergedAssociatedTypes().
 void RewriteSystem::checkMergedAssociatedType(Term lhs, Term rhs) {
+  // FIXME: Figure out 3-cell representation for merged associated types
+  if (RecordHomotopyGenerators)
+    return;
+
   if (lhs.size() == rhs.size() &&
       std::equal(lhs.begin(), lhs.end() - 1, rhs.begin()) &&
       lhs.back().getKind() == Symbol::Kind::AssociatedType &&
@@ -581,7 +585,7 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
               llvm::dbgs() << "\n\n";
 
               // Record the trivial loop.
-              HomotopyGenerators.push_back(loop);
+              recordHomotopyGenerator(loop);
             }
           }
         });