RequirementMachine: Don't simplify terms inside concrete substitutions when adding a rule

The effect of doing this is difficult to represent with homotopy generators,
so let's just not bother.

Author: slavapestov

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -162,11 +162,6 @@ static Type getTypeFromSubstitutionSchema(Type schema,
         // Skip creation of a new MutableTerm in the case where the
         // prefix is empty.
         return ctx.getTypeForTerm(substitution, genericParams, protos);
-      } else if (substitution.size() == 1 &&
-                 substitution[0].getKind() == Symbol::Kind::Protocol) {
-        // If the prefix is non-empty and the substitution is the
-        // protocol 'Self' type for some protocol, just use the prefix.
-        return ctx.getTypeForTerm(prefix, genericParams, protos);
       } else {
         // Otherwise build a new term by appending the substitution
         // to the prefix.

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -293,6 +293,23 @@ Type getTypeForSymbolRange(Iter begin, Iter end, Type root,
       continue;
     }
 
+    // We can end up with an unsimplified term like this:
+    //
+    // X.[P].[P:X]
+    //
+    // Simplification will rewrite X.[P] to X, so just ignore a protocol symbol
+    // in the middle of a term.
+    if (symbol.getKind() == Symbol::Kind::Protocol) {
+#ifndef NDEBUG
+      // Ensure that the domain of the suffix contains P.
+      if (begin + 1 < end) {
+        auto protos = (begin + 1)->getProtocols();
+        assert(std::find(protos.begin(), protos.end(), symbol.getProtocol()));
+      }
+#endif
+      continue;
+    }
+
     // We should have a resolved type at this point.
     auto *assocType =
         const_cast<RewriteContext &>(ctx)

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -66,13 +66,6 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs) {
     llvm::dbgs() << "# Adding rule " << lhs << " == " << rhs << "\n";
   }
 
-  // First, simplify terms appearing inside concrete substitutions before
-  // doing anything else.
-  if (lhs.back().isSuperclassOrConcreteType())
-    lhs.back() = simplifySubstitutionsInSuperclassOrConcreteSymbol(lhs.back());
-  else if (rhs.back().isSuperclassOrConcreteType())
-    rhs.back() = simplifySubstitutionsInSuperclassOrConcreteSymbol(rhs.back());
-
   // Now simplify both sides as much as possible with the rules we have so far.
   //
   // This avoids unnecessary work in the completion algorithm.