Implement SE-0253 review feedback.

Use `callAsFunction` as the call-syntax delegate method name.

Author: dan-zheng

include/swift/AST/Decl.h

@@ -5958,8 +5958,8 @@ class FuncDecl : public AbstractFunctionDecl {
   bool isConsuming() const {
     return getSelfAccessKind() == SelfAccessKind::__Consuming;
   }
-  bool isCallFunction() const {
-    return getName().str() == "callFunction" && isInstanceMember();
+  bool isCallAsFunctionMethod() const {
+    return getName().str() == "callAsFunction" && isInstanceMember();
   }
 
   SelfAccessKind getSelfAccessKind() const {

include/swift/AST/KnownIdentifiers.def

@@ -31,7 +31,7 @@ IDENTIFIER(Any)
 IDENTIFIER(ArrayLiteralElement)
 IDENTIFIER(atIndexedSubscript)
 IDENTIFIER_(bridgeToObjectiveC)
-IDENTIFIER(callFunction)
+IDENTIFIER(callAsFunction)
 IDENTIFIER_WITH_NAME(code_, "_code")
 IDENTIFIER(CodingKeys)
 IDENTIFIER(combine)

lib/Sema/CSApply.cpp

@@ -7051,8 +7051,8 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
       llvm_unreachable("Unhandled DeclTypeCheckingSemantics in switch.");
     };
 
-  // Save the original potentially lvalue function for rewriting call method
-  // applications.
+  // Save the original potentially lvalue function for rewriting
+  // `callAsFunction` method applications.
   auto *originalFn = fn;
   // The function is always an rvalue.
   fn = cs.coerceToRValue(fn);
@@ -7200,19 +7200,19 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
     return finishApply(apply, openedType, locator);
   }
 
-  // Handle call method applications.
+  // Handle `callAsFunction` method applications.
   auto &ctx = cs.getASTContext();
 
   TupleExpr *arg = dyn_cast<TupleExpr>(apply->getArg());
   if (auto parenExpr = dyn_cast<ParenExpr>(apply->getArg()))
     arg = TupleExpr::createImplicit(ctx, parenExpr->getSubExpr(), {});
 
-  // Get resolved call method and verify it.
+  // Get resolved `callAsFunction` method and verify it.
   auto loc = locator.withPathElement(ConstraintLocator::ApplyFunction);
   auto selected = solution.getOverloadChoice(cs.getConstraintLocator(loc));
   auto choice = selected.choice;
   auto *callMethod = dyn_cast<FuncDecl>(selected.choice.getDecl());
-  if (callMethod && callMethod->isCallFunction()) {
+  if (callMethod && callMethod->isCallAsFunctionMethod()) {
     auto methodType =
         simplifyType(selected.openedType)->castTo<AnyFunctionType>();
     auto selfParam = callMethod->getImplicitSelfDecl();
@@ -7227,7 +7227,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
       failure.diagnose();
       return nullptr;
     }
-    // Create direct reference to call method.
+    // Create direct reference to `callAsFunction` method.
     bool isDynamic = choice.getKind() == OverloadChoiceKind::DeclViaDynamic;
     Expr *declRef = buildMemberRef(originalFn, selected.openedFullType,
                                    /*dotLoc=*/SourceLoc(), choice,
@@ -7240,7 +7240,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
       return nullptr;
     declRef->setImplicit(apply->isImplicit());
     apply->setFn(declRef);
-    // Coerce argument to input type of call method.
+    // Coerce argument to input type of the `callAsFunction` method.
     SmallVector<Identifier, 2> argLabelsScratch;
     auto *arg = coerceCallArguments(apply->getArg(), methodType, apply,
                                     apply->getArgumentLabels(argLabelsScratch),

lib/Sema/CSDiag.cpp

@@ -4797,12 +4797,12 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
     auto isDynamicCallable =
         CS.DynamicCallableCache[fnType->getCanonicalType()].isValid();
 
-    // TODO: Consider caching?
+    // Note: Consider caching `hasCallAsFunctionMethods` in `NominalTypeDecl`.
     auto *nominal = fnType->getAnyNominal();
-    auto hasCallMethods = nominal &&
+    auto hasCallAsFunctionMethods = nominal &&
       llvm::any_of(nominal->getMembers(), [](Decl *member) {
           auto funcDecl = dyn_cast<FuncDecl>(member);
-          return funcDecl && funcDecl->isCallFunction();
+          return funcDecl && funcDecl->isCallAsFunctionMethod();
         });
 
     // Diagnose @dynamicCallable errors.
@@ -4862,7 +4862,7 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
         }
       }
 
-    if (!isDynamicCallable && !hasCallMethods)
+    if (!isDynamicCallable && !hasCallAsFunctionMethods)
       return true;
   }
 

lib/Sema/CSSimplify.cpp

@@ -5833,27 +5833,27 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     return simplified;
   }
 
-  // Handle applications of types with call methods.
+  // Handle applications of types with `callAsFunction` methods.
   if (desugar2->mayHaveMembers()) {
     auto &ctx = getASTContext();
-    // Get all call methods of the nominal type.
-    // TODO: Consider caching?
+    // Get all `callAsFunction` methods of the nominal type.
+    // Note: Consider caching `callAsFunction` methods.
     SmallVector<FuncDecl *, 4> callMethods;
-    auto candidates = lookupMember(desugar2, DeclName(ctx.Id_callFunction));
+    auto candidates = lookupMember(desugar2, DeclName(ctx.Id_callAsFunction));
     for (auto entry : candidates) {
       auto callMethod = dyn_cast<FuncDecl>(entry.getValueDecl());
       if (!callMethod)
         continue;
       callMethods.push_back(callMethod);
     }
 
-    // Handle call methods calls.
+    // Handle `callAsFunction` methods calls.
     if (!callMethods.empty()) {
-      // Create a type variable for the call method.
+      // Create a type variable for the `callAsFunction` method.
       auto loc = getConstraintLocator(locator);
       auto tv = createTypeVariable(loc, TVO_CanBindToLValue);
 
-      // Record the call method overload set.
+      // Record the `callAsFunction` method overload set.
       SmallVector<OverloadChoice, 4> choices;
       for (auto candidate : callMethods) {
         TC.validateDecl(candidate);

test/Sema/Inputs/call_as_function_other_module.swift

@@ -0,0 +1,11 @@
+public protocol Layer {
+  func callAsFunction(_ input: Float) -> Float
+}
+
+public struct Dense {
+  public init() {}
+
+  public func callAsFunction(_ input: Float) -> Float {
+    return input * 2
+  }
+}

test/Sema/Inputs/call_method_other_module.swift

@@ -1,8 +1,8 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend -emit-module -primary-file %S/Inputs/call_method_other_module.swift -emit-module-path %t/call_method_other_module.swiftmodule
+// RUN: %target-swift-frontend -emit-module -primary-file %S/Inputs/call_as_function_other_module.swift -emit-module-path %t/call_as_function_other_module.swiftmodule
 // RUN: %target-swift-frontend -typecheck -I %t -primary-file %s -verify
 
-import call_method_other_module
+import call_as_function_other_module
 
 func testLayer<L: Layer>(_ layer: L) -> Float {
   return layer(1)

test/Sema/call_method_cross_module.swift renamed to test/Sema/call_as_function_cross_module.swift

@@ -1,22 +1,22 @@
 // RUN: %target-typecheck-verify-swift
 
 protocol P0 {
-  func callFunction(x: Self)
+  func callAsFunction(x: Self)
 }
 
 struct ConcreteType {
-  func callFunction<T, U>(_ x: T, _ y: U) -> (T, U) {
+  func callAsFunction<T, U>(_ x: T, _ y: U) -> (T, U) {
     return (x, y)
   }
 
-  func callFunction<T, U>(_ fn: @escaping (T) -> U) -> (T) -> U {
+  func callAsFunction<T, U>(_ fn: @escaping (T) -> U) -> (T) -> U {
     return fn
   }
 }
 
 let concrete = ConcreteType()
 _ = concrete(1, 3.0)
-_ = concrete(concrete, concrete.callFunction as ([Int], Float) -> ([Int], Float))
+_ = concrete(concrete, concrete.callAsFunction as ([Int], Float) -> ([Int], Float))
 
 func generic<T, U>(_ x: T, _ y: U) {
   _ = concrete(x, x)
@@ -25,14 +25,14 @@ func generic<T, U>(_ x: T, _ y: U) {
 
 struct GenericType<T : Collection> {
   let collection: T
-  func callFunction<U>(_ x: U) -> Bool where U == T.Element, U : Equatable {
+  func callAsFunction<U>(_ x: U) -> Bool where U == T.Element, U : Equatable {
     return collection.contains(x)
   }
 }
 
 // Test conditional conformance.
 extension GenericType where T.Element : Numeric {
-  func callFunction(initialValue: T.Element) -> T.Element {
+  func callAsFunction(initialValue: T.Element) -> T.Element {
     return collection.reduce(initialValue, +)
   }
 }

test/Sema/call_method_generic.swift renamed to test/Sema/call_as_function_generic.swift

@@ -1,8 +1,8 @@
 // RUN: %target-typecheck-verify-swift
 
 protocol P0 {
-  // expected-note @+1 {{protocol requires function 'callFunction()' with type '() -> Missing'; do you want to add a stub?}}
-  func callFunction() -> Self
+  // expected-note @+1 {{protocol requires function 'callAsFunction()' with type '() -> Missing'; do you want to add a stub?}}
+  func callAsFunction() -> Self
 }
 func testProtocol(_ x: P0) {
   _ = x()
@@ -12,18 +12,18 @@ func testGeneric<T : P0>(_ x: T) {
 }
 
 protocol P1 {
-  func callFunction() -> Self
+  func callAsFunction() -> Self
 }
 extension P1 {
   // expected-note @+1 {{found this candidate}}
-  func callFunction() -> Self {
+  func callAsFunction() -> Self {
     return self
   }
 }
 protocol P2 {}
 extension P2 {
   // expected-note @+1 {{found this candidate}}
-  func callFunction(x: Int, y: Int) -> Int {
+  func callAsFunction(x: Int, y: Int) -> Int {
     return x + y
   }
 }
@@ -32,13 +32,13 @@ extension P2 {
 struct Missing : P0 {}
 struct S0 : P0 {
   @discardableResult
-  func callFunction() -> S0 { return self }
+  func callAsFunction() -> S0 { return self }
 }
 let s0 = S0()
 s0()
 
 struct S1 : P1 {
-  func callFunction() -> S1 { return self }
+  func callAsFunction() -> S1 { return self }
 }
 
 let s1 = S1()
@@ -47,13 +47,13 @@ _ = s1()()
 struct Conforming : P0 & P1 & P2 {}
 let conforming = Conforming()
 _ = conforming(x: 1, y: 2)
-_ = conforming().callFunction(x:y:)(1, 2)
-_ = conforming.callFunction(x:y:)
-_ = conforming.callFunction // expected-error {{ambiguous use of 'callFunction'}}
+_ = conforming().callAsFunction(x:y:)(1, 2)
+_ = conforming.callAsFunction(x:y:)
+_ = conforming.callAsFunction // expected-error {{ambiguous use of 'callAsFunction'}}
 
 protocol P3 {}
 extension P3 {
-  func callFunction() -> Self { return self }
+  func callAsFunction() -> Self { return self }
 }
 struct S3 : P3 {}