[ConstraintSystem] Rename IsDeclSubstitutableRequest to

IsDeclRefinementOfRequest to better reflect what it computes.

Author: hborla

include/swift/AST/TypeCheckRequests.h

@@ -1883,11 +1883,11 @@ class CompareDeclSpecializationRequest
   bool isCached() const { return true; }
 };
 
-/// Checks whether substituting the first generic function decl with the
-/// second generic function decl will satisfy all requirements and produce
-/// the same function type.
-class IsDeclSubstitutableRequest
-    : public SimpleRequest<IsDeclSubstitutableRequest,
+/// Checks whether the first function decl is a refinement of the second,
+/// meaning the two functions have the same structure, and the requirements
+/// of the first are refining the requirements of the second.
+class IsDeclRefinementOfRequest
+    : public SimpleRequest<IsDeclRefinementOfRequest,
                            bool(ValueDecl *, ValueDecl *),
                            RequestFlags::Cached> {
 public:

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -41,7 +41,7 @@ SWIFT_REQUEST(TypeChecker, CodeCompletionFileRequest,
 SWIFT_REQUEST(TypeChecker, CompareDeclSpecializationRequest,
               bool (DeclContext *, ValueDecl *, ValueDecl *, bool), Cached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsDeclSubstitutableRequest,
+SWIFT_REQUEST(TypeChecker, IsDeclRefinementOfRequest,
               bool (ValueDecl *, ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CustomAttrTypeRequest,

lib/Sema/CSSolver.cpp

@@ -2197,7 +2197,7 @@ void ConstraintSystem::partitionDisjunction(
     auto *declA = dyn_cast<ValueDecl>(Choices[lhs]->getOverloadChoice().getDecl());
     auto *declB = dyn_cast<ValueDecl>(Choices[rhs]->getOverloadChoice().getDecl());
 
-    return TypeChecker::isDeclSubstitutable(declA, declB);
+    return TypeChecker::isDeclRefinementOf(declA, declB);
   });
 
   everythingElse.append(genericOverloads.begin(), genericOverloads.end());

lib/Sema/CSStep.cpp

@@ -530,7 +530,7 @@ StepResult DisjunctionStep::resume(bool prevFailed) {
   return take(prevFailed);
 }
 
-bool IsDeclSubstitutableRequest::evaluate(Evaluator &evaluator,
+bool IsDeclRefinementOfRequest::evaluate(Evaluator &evaluator,
                                           ValueDecl *declA,
                                           ValueDecl *declB) const {
   auto *typeA = declA->getInterfaceType()->getAs<GenericFunctionType>();
@@ -574,9 +574,9 @@ bool IsDeclSubstitutableRequest::evaluate(Evaluator &evaluator,
   return substTypeA->isEqual(substTypeB);
 }
 
-bool TypeChecker::isDeclSubstitutable(ValueDecl *declA, ValueDecl *declB) {
+bool TypeChecker::isDeclRefinementOf(ValueDecl *declA, ValueDecl *declB) {
   return evaluateOrDefault(declA->getASTContext().evaluator,
-                           IsDeclSubstitutableRequest{ declA, declB },
+                           IsDeclRefinementOfRequest{ declA, declB },
                            false);
 }
 
@@ -616,7 +616,7 @@ bool DisjunctionStep::shouldSkip(const DisjunctionChoice &choice) const {
     auto *declA = LastSolvedChoice->first->getOverloadChoice().getDecl();
     auto *declB = static_cast<Constraint *>(choice)->getOverloadChoice().getDecl();
 
-    if (TypeChecker::isDeclSubstitutable(declA, declB))
+    if (TypeChecker::isDeclRefinementOf(declA, declB))
       return skip("subtype");
   }
 

lib/Sema/TypeChecker.h

@@ -906,7 +906,7 @@ Comparison compareDeclarations(DeclContext *dc, ValueDecl *decl1,
 /// Checks whether the first decl is a refinement of the second
 /// decl, meaning that the second decl can always be used in place
 /// of the first one and the expression will still type check.
-bool isDeclSubstitutable(ValueDecl *declA, ValueDecl *declB);
+bool isDeclRefinementOf(ValueDecl *declA, ValueDecl *declB);
 
 /// Build a type-checked reference to the given value.
 Expr *buildCheckedRefExpr(VarDecl *D, DeclContext *UseDC, DeclNameLoc nameLoc,