RequirementMachine: Factor out Symbol::withConcreteSubstitutions()

Author: slavapestov

lib/AST/RequirementMachine/RewriteLoop.cpp

@@ -312,14 +312,7 @@ void RewritePathEvaluator::applyDecompose(const RewriteStep &step,
     }
 
     // Build the new symbol with the new substitutions.
-    auto newSymbol = (symbol.getKind() == Symbol::Kind::Superclass
-                      ? Symbol::forSuperclass(symbol.getSuperclass(),
-                                              substitutions, ctx)
-                      : Symbol::forConcreteType(symbol.getConcreteType(),
-                                                substitutions, ctx));
-
-    // Update the term with the new symbol.
-    term.back() = newSymbol;
+    term.back() = symbol.withConcreteSubstitutions(substitutions, ctx);
 
     // Pop the substitutions from the A stack.
     A.resize(A.size() - numSubstitutions);

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -285,33 +285,7 @@ void RewriteSystem::simplifySubstitutions(MutableTerm &term,
   }
 
   // Build the new symbol with simplified substitutions.
-  switch (symbol.getKind()) {
-  case Symbol::Kind::Superclass:
-    term.back() = Symbol::forSuperclass(symbol.getSuperclass(),
-                                        newSubstitutions, Context);
-    return;
-
-  case Symbol::Kind::ConcreteType:
-    term.back() = Symbol::forConcreteType(symbol.getConcreteType(),
-                                          newSubstitutions, Context);
-    return;
-
-  case Symbol::Kind::ConcreteConformance:
-    term.back() = Symbol::forConcreteConformance(symbol.getConcreteType(),
-                                                 newSubstitutions,
-                                                 symbol.getProtocol(),
-                                                 Context);
-    return;
-
-  case Symbol::Kind::Protocol:
-  case Symbol::Kind::Name:
-  case Symbol::Kind::AssociatedType:
-  case Symbol::Kind::GenericParam:
-  case Symbol::Kind::Layout:
-    break;
-  }
-
-  llvm_unreachable("Bad symbol kind");
+  term.back() = symbol.withConcreteSubstitutions(newSubstitutions, Context);
 }
 
 /// Adds a rewrite rule, returning true if the new rule was non-trivial.

lib/AST/RequirementMachine/Symbol.cpp

@@ -646,6 +646,31 @@ int Symbol::compare(Symbol other, RewriteContext &ctx) const {
   return result;
 }
 
+Symbol Symbol::withConcreteSubstitutions(
+    ArrayRef<Term> substitutions,
+    RewriteContext &ctx) const {
+  switch (getKind()) {
+  case Kind::Superclass:
+    return Symbol::forSuperclass(getSuperclass(), substitutions, ctx);
+
+  case Kind::ConcreteType:
+    return Symbol::forConcreteType(getConcreteType(), substitutions, ctx);
+
+  case Kind::ConcreteConformance:
+    return Symbol::forConcreteConformance(getConcreteType(), substitutions,
+                                          getProtocol(), ctx);
+
+  case Kind::GenericParam:
+  case Kind::Name:
+  case Kind::Protocol:
+  case Kind::AssociatedType:
+  case Kind::Layout:
+    break;
+  }
+
+  llvm_unreachable("Bad symbol kind");
+}
+
 /// For a superclass or concrete type symbol
 ///
 ///   [concrete: Foo<X1, ..., Xn>]
@@ -679,26 +704,7 @@ Symbol Symbol::transformConcreteSubstitutions(
   if (!anyChanged)
     return *this;
 
-  switch (getKind()) {
-  case Kind::Superclass:
-    return Symbol::forSuperclass(getSuperclass(), substitutions, ctx);
-
-  case Kind::ConcreteType:
-    return Symbol::forConcreteType(getConcreteType(), substitutions, ctx);
-
-  case Kind::ConcreteConformance:
-    return Symbol::forConcreteConformance(getConcreteType(), substitutions,
-                                          getProtocol(), ctx);
-
-  case Kind::GenericParam:
-  case Kind::Name:
-  case Kind::Protocol:
-  case Kind::AssociatedType:
-  case Kind::Layout:
-    break;
-  }
-
-  llvm_unreachable("Bad symbol kind");
+  return withConcreteSubstitutions(substitutions, ctx);
 }
 
 /// Print the symbol using our mnemonic representation.

lib/AST/RequirementMachine/Symbol.h

@@ -227,6 +227,10 @@ class Symbol final {
 
   int compare(Symbol other, RewriteContext &ctx) const;
 
+  Symbol withConcreteSubstitutions(
+      ArrayRef<Term> substitutions,
+      RewriteContext &ctx) const;
+
   Symbol transformConcreteSubstitutions(
       llvm::function_ref<Term(Term)> fn,
       RewriteContext &ctx) const;