Introduce callables.

Introduce callables: values that can be called like functions.
Methods named `func callFunction` act as call-syntax delegate methods.

```
struct Adder {
  var base: Int
  func callFunction(_ x: Int) -> Int {
    return x + base
  }
}
var adder = Adder(base: 3)
adder(10) // desugars to `adder.callFunction(10)`
```

Author: dan-zheng

include/swift/AST/Decl.h

@@ -5958,6 +5958,9 @@ class FuncDecl : public AbstractFunctionDecl {
   bool isConsuming() const {
     return getSelfAccessKind() == SelfAccessKind::__Consuming;
   }
+  bool isCallable() const {
+    return getName().str() == "call" && isInstanceMember();
+  }
 
   SelfAccessKind getSelfAccessKind() const {
     return static_cast<SelfAccessKind>(Bits.FuncDecl.SelfAccess);

include/swift/AST/KnownIdentifiers.def

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

lib/Sema/CSApply.cpp

@@ -7067,6 +7067,9 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
       llvm_unreachable("Unhandled DeclTypeCheckingSemantics in switch.");
     };
 
+  // Save the original potentially lvalue function for rewriting call method
+  // applications.
+  auto *originalFn = fn;
   // The function is always an rvalue.
   fn = cs.coerceToRValue(fn);
 
@@ -7213,6 +7216,59 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
     return finishApply(apply, openedType, locator);
   }
 
+  // Handle call 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.
+  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->isCallable()) {
+    auto methodType =
+        simplifyType(selected.openedType)->castTo<AnyFunctionType>();
+    auto selfParam = callMethod->getImplicitSelfDecl();
+    // Diagnose `mutating` method call on immutable value.
+    // FIXME(TF-444): This logic for `mutating` method calls incorrectly rejects
+    // IUOs. Performing this ad-hoc check using `originalFn` feels hacky;
+    // rewrite if possible.
+    if (!cs.getType(originalFn)->hasLValueType() && selfParam->isInOut()) {
+      AssignmentFailure failure(originalFn, cs, originalFn->getLoc(),
+                                diag::cannot_pass_rvalue_mutating_subelement,
+                                diag::cannot_pass_rvalue_mutating);
+      failure.diagnose();
+      return nullptr;
+    }
+    // Create direct reference to call method.
+    bool isDynamic = choice.getKind() == OverloadChoiceKind::DeclViaDynamic;
+    Expr *declRef = buildMemberRef(originalFn, selected.openedFullType,
+                                   /*dotLoc=*/SourceLoc(), choice,
+                                   DeclNameLoc(fn->getEndLoc()),
+                                   selected.openedType, loc, loc,
+                                   /*Implicit=*/true,
+                                   choice.getFunctionRefKind(),
+                                   AccessSemantics::Ordinary, isDynamic);
+    if (!declRef)
+      return nullptr;
+    declRef->setImplicit(apply->isImplicit());
+    apply->setFn(declRef);
+    // Coerce argument to input type of call method.
+    SmallVector<Identifier, 2> argLabelsScratch;
+    auto *arg = coerceCallArguments(apply->getArg(), methodType, apply,
+                                    apply->getArgumentLabels(argLabelsScratch),
+                                    apply->hasTrailingClosure(), loc);
+    if (!arg)
+      return nullptr;
+    apply->setArg(arg);
+    cs.setType(apply, methodType->getResult());
+    cs.cacheExprTypes(apply);
+    return apply;
+  }
+
   // Handle @dynamicCallable applications.
   // At this point, all other ApplyExpr cases have been handled.
   return finishApplyDynamicCallable(cs, solution, apply, locator);

lib/Sema/CSDiag.cpp

@@ -4796,9 +4796,19 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
       !fnType->is<AnyFunctionType>() && !fnType->is<MetatypeType>()) {
 
     auto arg = callExpr->getArg();
+    auto isDynamicCallable =
+        CS.DynamicCallableCache[fnType->getCanonicalType()].isValid();
+
+    // TODO: Consider caching?
+    auto *nominal = fnType->getAnyNominal();
+    auto hasCallMethods = nominal &&
+      llvm::any_of(nominal->getMembers(), [](Decl *member) {
+          auto funcDecl = dyn_cast<FuncDecl>(member);
+          return funcDecl && funcDecl->isCallable();
+        });
 
     // Diagnose @dynamicCallable errors.
-    if (CS.DynamicCallableCache[fnType->getCanonicalType()].isValid()) {
+    if (isDynamicCallable) {
       auto dynamicCallableMethods =
         CS.DynamicCallableCache[fnType->getCanonicalType()];
 
@@ -4854,7 +4864,8 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
         }
       }
 
-    return true;
+    if (!isDynamicCallable && !hasCallMethods)
+      return true;
   }
 
   bool hasTrailingClosure = callArgHasTrailingClosure(callExpr->getArg());

lib/Sema/CSSimplify.cpp

@@ -5788,6 +5788,60 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     return simplified;
   }
 
+  // Handle applications of types with call methods.
+  if (desugar2->mayHaveMembers()) {
+    auto &ctx = getASTContext();
+    // Get all call methods of the nominal type.
+    // TODO: Consider caching?
+    SmallVector<FuncDecl *, 4> callMethods;
+    auto candidates = lookupMember(desugar2, DeclName(ctx.Id_call));
+    for (auto entry : candidates) {
+      auto callMethod = dyn_cast<FuncDecl>(entry.getValueDecl());
+      if (!callMethod)
+        continue;
+      callMethods.push_back(callMethod);
+    }
+
+    // Handle call methods calls.
+    if (!callMethods.empty()) {
+      // Create a type variable for the call method.
+      auto loc = getConstraintLocator(locator);
+      auto tv = createTypeVariable(loc, TVO_CanBindToLValue);
+
+      // Record the call method overload set.
+      SmallVector<OverloadChoice, 4> choices;
+      for (auto candidate : callMethods) {
+        TC.validateDecl(candidate);
+        if (candidate->isInvalid()) continue;
+        choices.push_back(
+            OverloadChoice(type2, candidate, FunctionRefKind::SingleApply));
+      }
+      if (choices.empty()) return SolutionKind::Error;
+      addOverloadSet(tv, choices, DC, loc);
+
+      // Create type variables for each parameter type.
+      SmallVector<AnyFunctionType::Param, 4> tvParams;
+      for (unsigned i : range(func1->getNumParams())) {
+        auto param = func1->getParams()[i];
+        auto paramType = param.getPlainType();
+
+        auto *tvParam = createTypeVariable(loc, TVO_CanBindToNoEscape);
+        auto locatorBuilder =
+            locator.withPathElement(LocatorPathElt::getTupleElement(i));
+        addConstraint(ConstraintKind::ArgumentConversion, paramType,
+                      tvParam, locatorBuilder);
+        tvParams.push_back(AnyFunctionType::Param(
+            tvParam, Identifier(), param.getParameterFlags()));
+      }
+      // Create target function type and an applicable function constraint.
+      AnyFunctionType *funcType =
+          FunctionType::get(tvParams, func1->getResult());
+      addConstraint(ConstraintKind::ApplicableFunction, funcType, tv, locator);
+
+      return SolutionKind::Solved;
+    }
+  }
+
   // Handle applications of @dynamicCallable types.
   return simplifyDynamicCallableApplicableFnConstraint(type1, origType2,
                                                        subflags, locator);

test/Sema/Inputs/call_method_other_module.swift

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

test/Sema/call_method_cross_module.swift

@@ -0,0 +1,14 @@
+// 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 -typecheck -I %t -primary-file %s -verify
+
+import call_method_other_module
+
+func testLayer<L: Layer>(_ layer: L) -> Float {
+  return layer(1)
+}
+
+func testDense() -> Float {
+  let dense = Dense()
+  return dense(1)
+}

test/Sema/call_method_generic.swift

@@ -0,0 +1,43 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P0 {
+  func call(x: Self)
+}
+
+struct ConcreteType {
+  func call<T, U>(_ x: T, _ y: U) -> (T, U) {
+    return (x, y)
+  }
+
+  func call<T, U>(_ fn: @escaping (T) -> U) -> (T) -> U {
+    return fn
+  }
+}
+
+let concrete = ConcreteType()
+_ = concrete(1, 3.0)
+_ = concrete(concrete, concrete.call as ([Int], Float) -> ([Int], Float))
+
+func generic<T, U>(_ x: T, _ y: U) {
+  _ = concrete(x, x)
+  _ = concrete(x, y)
+}
+
+struct GenericType<T : Collection> {
+  let collection: T
+  func call<U>(_ x: U) -> Bool where U == T.Element, U : Equatable {
+    return collection.contains(x)
+  }
+}
+
+// Test conditional conformance.
+extension GenericType where T.Element : Numeric {
+  func call(initialValue: T.Element) -> T.Element {
+    return collection.reduce(initialValue, +)
+  }
+}
+
+let genericString = GenericType<[String]>(collection: ["Hello", "world", "!"])
+_ = genericString("Hello")
+let genericInt = GenericType<Set<Int>>(collection: [1, 2, 3])
+_ = genericInt(initialValue: 1)

test/Sema/call_method_protocol.swift

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