[AST] Rename isCallableNominalType -> isCallAsFunctionType

Make it explicit that we're checking for
`callAsFunction` instead of `dynamicallyCall`.

Author: hamishknight

include/swift/AST/Types.h

@@ -921,7 +921,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Checks whether this is a type that supports being called through the
   /// implementation of a \c callAsFunction method. Note that this does not
   /// check access control.
-  bool isCallableNominalType(DeclContext *dc);
+  bool isCallAsFunctionType(DeclContext *dc);
 
   /// Return true if the specified type or a super-class/super-protocol has the
   /// @dynamicMemberLookup attribute on it.

lib/AST/Type.cpp

@@ -2006,7 +2006,7 @@ bool TypeBase::satisfiesClassConstraint() {
   return mayHaveSuperclass() || isObjCExistentialType();
 }
 
-bool TypeBase::isCallableNominalType(DeclContext *dc) {
+bool TypeBase::isCallAsFunctionType(DeclContext *dc) {
   // Don't allow callAsFunction to be used with dynamic lookup.
   if (isAnyObject())
     return false;

lib/Sema/CSApply.cpp

@@ -7749,7 +7749,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
 
   // If this is an implicit call to a `callAsFunction` method, build the
   // appropriate member reference.
-  if (cs.getType(fn)->getRValueType()->isCallableNominalType(dc)) {
+  if (cs.getType(fn)->getRValueType()->isCallAsFunctionType(dc)) {
     fn = buildCallAsFunctionMethodRef(*this, apply, *overload, calleeLoc);
     if (!fn)
       return nullptr;

lib/Sema/CSDiagnostics.cpp

@@ -147,7 +147,7 @@ Expr *FailureDiagnostic::getBaseExprFor(const Expr *anchor) const {
     return MRE->getBase();
   else if (auto *call = dyn_cast<CallExpr>(anchor)) {
     auto fnType = getType(call->getFn());
-    if (fnType->isCallableNominalType(getDC())) {
+    if (fnType->isCallAsFunctionType(getDC())) {
       return call->getFn();
     }
   }

lib/Sema/CSSimplify.cpp

@@ -1185,7 +1185,7 @@ class ArgumentFailureTracker : public MatchCallArgumentListener {
         argIdx == *UnlabeledTrailingClosureArgIndex && Callee) {
       if (auto *ctor = dyn_cast<ConstructorDecl>(Callee.get())) {
         auto resultTy = ctor->getResultInterfaceType();
-        if (resultTy->isCallableNominalType(CS.DC))
+        if (resultTy->isCallAsFunctionType(CS.DC))
           return true;
       }
     }
@@ -10985,7 +10985,7 @@ bool ConstraintSystem::simplifyAppliedOverloadsImpl(
         auto *dc = decl->getDeclContext();
         if (auto *parent = dc->getSelfNominalTypeDecl()) {
           auto type = parent->getDeclaredInterfaceType();
-          if (type->isCallableNominalType(DC))
+          if (type->isCallAsFunctionType(DC))
             return false;
         }
       }
@@ -11330,7 +11330,7 @@ ConstraintSystem::simplifyApplicableFnConstraint(
   // Handle applications of types with `callAsFunction` methods.
   // Do this before stripping optional types below, when `shouldAttemptFixes()`
   // is true.
-  if (desugar2->isCallableNominalType(DC)) {
+  if (desugar2->isCallAsFunctionType(DC)) {
     auto memberLoc = getConstraintLocator(
         locator.withPathElement(ConstraintLocator::ImplicitCallAsFunction));
     // Add a `callAsFunction` member constraint, binding the member type to a
@@ -11391,7 +11391,7 @@ ConstraintSystem::simplifyApplicableFnConstraint(
       // trailing closure(s), closure(s) might not belong to
       // the constructor but rather to implicit `callAsFunction`,
       // there is no way to determine that without trying.
-      if (resultTy->isCallableNominalType(DC) &&
+      if (resultTy->isCallAsFunctionType(DC) &&
           argumentList->hasAnyTrailingClosures()) {
         auto *calleeLoc = getCalleeLocator(argumentsLoc);
 
@@ -11553,7 +11553,7 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     // once constraint generation is done.
     if (getPhase() == ConstraintSystemPhase::ConstraintGeneration &&
         argumentList->hasAnyTrailingClosures() &&
-        instance2->isCallableNominalType(DC)) {
+        instance2->isCallAsFunctionType(DC)) {
       return formUnsolved(/*activate=*/true);
     }
 

lib/Sema/ConstraintSystem.cpp

@@ -567,7 +567,7 @@ ConstraintLocator *ConstraintSystem::getCalleeLocator(
     }
 
     // Handle an apply of a nominal type which supports callAsFunction.
-    if (fnTy->isCallableNominalType(DC)) {
+    if (fnTy->isCallAsFunctionType(DC)) {
       return getConstraintLocator(anchor,
                                   {LocatorPathElt::ApplyFunction(),
                                    LocatorPathElt::ImplicitCallAsFunction()});