RequirementMachine: Factor out getRuleForRequirement() from RuleBuilder::addRequirement()

Author: slavapestov

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -493,3 +493,32 @@ Type PropertyMap::getTypeFromSubstitutionSchema(
     return None;
   });
 }
+
+/// Given a concrete type that may contain type parameters in structural positions,
+/// collect all the structural type parameter components, and replace them all with
+/// fresh generic parameters. The fresh generic parameters all have a depth of 0,
+/// and the index is an index into the 'result' array.
+///
+/// For example, given the concrete type Foo<X.Y, Array<Z>>, this produces the
+/// result type Foo<τ_0_0, Array<τ_0_1>>, with result array {X.Y, Z}.
+CanType
+RewriteContext::getSubstitutionSchemaFromType(CanType concreteType,
+                                              const ProtocolDecl *proto,
+                                              SmallVectorImpl<Term> &result) {
+  assert(!concreteType->isTypeParameter() && "Must have a concrete type here");
+
+  if (!concreteType->hasTypeParameter())
+    return concreteType;
+
+  return CanType(concreteType.transformRec([&](Type t) -> Optional<Type> {
+    if (!t->isTypeParameter())
+      return None;
+
+    unsigned index = result.size();
+    result.push_back(getTermForType(CanType(t), proto));
+
+    return CanGenericTypeParamType::get(/*type sequence=*/ false,
+                                        /*depth=*/0, index,
+                                        Context);
+  }));
+}

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -774,35 +774,6 @@ ProtocolDependenciesRequest::evaluate(Evaluator &evaluator,
 // Building rewrite rules from desugared requirements.
 //
 
-/// Given a concrete type that may contain type parameters in structural positions,
-/// collect all the structural type parameter components, and replace them all with
-/// fresh generic parameters. The fresh generic parameters all have a depth of 0,
-/// and the index is an index into the 'result' array.
-///
-/// For example, given the concrete type Foo<X.Y, Array<Z>>, this produces the
-/// result type Foo<τ_0_0, Array<τ_0_1>>, with result array {X.Y, Z}.
-CanType
-RuleBuilder::getConcreteSubstitutionSchema(CanType concreteType,
-                                           const ProtocolDecl *proto,
-                                           SmallVectorImpl<Term> &result) {
-  assert(!concreteType->isTypeParameter() && "Must have a concrete type here");
-
-  if (!concreteType->hasTypeParameter())
-    return concreteType;
-
-  return CanType(concreteType.transformRec([&](Type t) -> Optional<Type> {
-    if (!t->isTypeParameter())
-      return None;
-
-    unsigned index = result.size();
-    result.push_back(Context.getTermForType(CanType(t), proto));
-
-    return CanGenericTypeParamType::get(/*type sequence=*/ false,
-                                        /*depth=*/0, index,
-                                        Context.getASTContext());
-  }));
-}
-
 void RuleBuilder::addRequirements(ArrayRef<Requirement> requirements) {
   // Collect all protocols transitively referenced from these requirements.
   for (auto req : requirements) {
@@ -861,7 +832,7 @@ void RuleBuilder::addAssociatedType(const AssociatedTypeDecl *type,
   PermanentRules.emplace_back(lhs, rhs);
 }
 
-/// Lowers a generic requirement to a rewrite rule.
+/// Lowers a desugared generic requirement to a rewrite rule.
 ///
 /// If \p proto is null, this is a generic requirement from the top-level
 /// generic signature. The added rewrite rule will be rooted in a generic
@@ -870,17 +841,13 @@ void RuleBuilder::addAssociatedType(const AssociatedTypeDecl *type,
 /// If \p proto is non-null, this is a generic requirement in the protocol's
 /// requirement signature. The added rewrite rule will be rooted in a
 /// protocol symbol.
-void RuleBuilder::addRequirement(const Requirement &req,
-                                 const ProtocolDecl *proto) {
-  if (Dump) {
-    llvm::dbgs() << "+ ";
-    req.dump(llvm::dbgs());
-    llvm::dbgs() << "\n";
-  }
-
+std::pair<MutableTerm, MutableTerm>
+swift::rewriting::getRuleForRequirement(const Requirement &req,
+                                        const ProtocolDecl *proto,
+                                        RewriteContext &ctx) {
   // Compute the left hand side.
   auto subjectType = CanType(req.getFirstType());
-  auto subjectTerm = Context.getMutableTermForType(subjectType, proto);
+  auto subjectTerm = ctx.getMutableTermForType(subjectType, proto);
 
   // Compute the right hand side.
   MutableTerm constraintTerm;
@@ -895,7 +862,7 @@ void RuleBuilder::addRequirement(const Requirement &req,
     auto *proto = req.getProtocolDecl();
 
     constraintTerm = subjectTerm;
-    constraintTerm.add(Symbol::forProtocol(proto, Context));
+    constraintTerm.add(Symbol::forProtocol(proto, ctx));
     break;
   }
 
@@ -907,10 +874,10 @@ void RuleBuilder::addRequirement(const Requirement &req,
 
     // Build the symbol [superclass: C<X, Y>].
     SmallVector<Term, 1> substitutions;
-    otherType = getConcreteSubstitutionSchema(otherType, proto,
-                                              substitutions);
+    otherType = ctx.getSubstitutionSchemaFromType(otherType, proto,
+                                                  substitutions);
     auto superclassSymbol = Symbol::forSuperclass(otherType, substitutions,
-                                                  Context);
+                                                  ctx);
 
     // Build the term T.[superclass: C<X, Y>].
     constraintTerm = subjectTerm;
@@ -924,7 +891,7 @@ void RuleBuilder::addRequirement(const Requirement &req,
     //   T.[layout: L] == T
     constraintTerm = subjectTerm;
     constraintTerm.add(Symbol::forLayout(req.getLayoutConstraint(),
-                                         Context));
+                                         ctx));
     break;
   }
 
@@ -937,21 +904,32 @@ void RuleBuilder::addRequirement(const Requirement &req,
       //
       //   T.[concrete: C<X, Y>] => T
       SmallVector<Term, 1> substitutions;
-      otherType = getConcreteSubstitutionSchema(otherType, proto,
-                                                substitutions);
+      otherType = ctx.getSubstitutionSchemaFromType(otherType, proto,
+                                                    substitutions);
 
       constraintTerm = subjectTerm;
       constraintTerm.add(Symbol::forConcreteType(otherType, substitutions,
-                                                 Context));
+                                                 ctx));
       break;
     }
 
-    constraintTerm = Context.getMutableTermForType(otherType, proto);
+    constraintTerm = ctx.getMutableTermForType(otherType, proto);
     break;
   }
   }
 
-  RequirementRules.emplace_back(subjectTerm, constraintTerm);
+  return std::make_pair(subjectTerm, constraintTerm);
+}
+
+void RuleBuilder::addRequirement(const Requirement &req,
+                                 const ProtocolDecl *proto) {
+  if (Dump) {
+    llvm::dbgs() << "+ ";
+    req.dump(llvm::dbgs());
+    llvm::dbgs() << "\n";
+  }
+
+  RequirementRules.push_back(getRuleForRequirement(req, proto, Context));
 }
 
 void RuleBuilder::addRequirement(const StructuralRequirement &req,

lib/AST/RequirementMachine/RequirementLowering.h

@@ -52,6 +52,11 @@ void realizeInheritedRequirements(TypeDecl *decl, Type type,
                                   ModuleDecl *moduleForInference,
                                   SmallVectorImpl<StructuralRequirement> &result);
 
+std::pair<MutableTerm, MutableTerm>
+getRuleForRequirement(const Requirement &req,
+                      const ProtocolDecl *proto,
+                      RewriteContext &ctx);
+
 /// A utility class for bulding rewrite rules from the top-level requirements
 /// of a generic signature.
 ///
@@ -89,10 +94,6 @@ struct RuleBuilder {
   /// eliminated by homotopy reduction.
   std::vector<std::pair<MutableTerm, MutableTerm>> RequirementRules;
 
-  CanType getConcreteSubstitutionSchema(CanType concreteType,
-                                        const ProtocolDecl *proto,
-                                        SmallVectorImpl<Term> &result);
-
   RuleBuilder(RewriteContext &ctx, bool dump) : Context(ctx), Dump(dump) {}
   void addRequirements(ArrayRef<Requirement> requirements);
   void addRequirements(ArrayRef<StructuralRequirement> requirements);

lib/AST/RequirementMachine/RewriteContext.h

@@ -170,6 +170,10 @@ class RewriteContext final {
   MutableTerm getRelativeTermForType(CanType typeWitness,
                                      ArrayRef<Term> substitutions);
 
+  CanType getSubstitutionSchemaFromType(CanType concreteType,
+                                        const ProtocolDecl *proto,
+                                        SmallVectorImpl<Term> &result);
+
   AssociatedTypeDecl *getAssociatedTypeForSymbol(Symbol symbol);
 
   Symbol mergeAssociatedTypes(Symbol lhs, Symbol rhs);