[CS] Apply all finishApply's transforms to callAsFunction

Rather than coercing the call arguments ourselves,
just build the finished member reference for the
callAsFunction method, and let finishApply do the
rest. This allows us to deal with transformations
such as IUO unwraps.

Resolves SR-11881.

Author: hamishknight

lib/Sema/CSApply.cpp

@@ -6495,12 +6495,10 @@ static bool isValidDynamicCallableMethod(FuncDecl *method,
   return true;
 }
 
-// Resolve `callAsFunction` method applications.
-static Expr *finishApplyCallAsFunctionMethod(
+// Build a reference to a `callAsFunction` method.
+static Expr *buildCallAsFunctionMethodRef(
     ExprRewriter &rewriter, ApplyExpr *apply, SelectedOverload selected,
-    AnyFunctionType *openedMethodType,
     ConstraintLocatorBuilder applyFunctionLoc) {
-  auto &cs = rewriter.cs;
   auto *fn = apply->getFn();
   auto choice = selected.choice;
   // Create direct reference to `callAsFunction` method.
@@ -6512,21 +6510,7 @@ static Expr *finishApplyCallAsFunctionMethod(
   if (!declRef)
     return nullptr;
   declRef->setImplicit(apply->isImplicit());
-  apply->setFn(declRef);
-  // Coerce argument to input type of the `callAsFunction` method.
-  auto callee = rewriter.resolveConcreteDeclRef(choice.getDecl(),
-                                                applyFunctionLoc);
-  SmallVector<Identifier, 2> argLabelsScratch;
-  auto *arg = rewriter.coerceCallArguments(
-      apply->getArg(), openedMethodType, callee, apply,
-      apply->getArgumentLabels(argLabelsScratch), apply->hasTrailingClosure(),
-      applyFunctionLoc);
-  if (!arg)
-    return nullptr;
-  apply->setArg(arg);
-  cs.setType(apply, openedMethodType->getResult());
-  cs.cacheExprTypes(apply);
-  return apply;
+  return declRef;
 }
 
 // Resolve `@dynamicCallable` applications.
@@ -6768,12 +6752,19 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, ConcreteDeclRef callee,
     auto methodType =
         simplifyType(selected->openedType)->getAs<AnyFunctionType>();
     if (method && methodType) {
-      if (method->isCallAsFunctionMethod())
-        return finishApplyCallAsFunctionMethod(
-            *this, apply, *selected, methodType, applyFunctionLoc);
-      if (methodType && isValidDynamicCallableMethod(method, methodType))
+      // Handle a call to a @dynamicCallable method.
+      if (isValidDynamicCallableMethod(method, methodType))
         return finishApplyDynamicCallable(
             apply, *selected, method, methodType, applyFunctionLoc);
+
+      // If this is an implicit call to a callAsFunction method, build the
+      // appropriate member reference.
+      if (method->isCallAsFunctionMethod()) {
+        fn = buildCallAsFunctionMethodRef(*this, apply, *selected,
+                                          applyFunctionLoc);
+        if (!fn)
+          return nullptr;
+      }
     }
   }
 

test/Sema/call_as_function_simple.swift

@@ -204,3 +204,18 @@ func testDefaults(_ x: DoubleANumber) {
   x(5)
   x(5, completion: { _ in })
 }
+
+// SR-11881
+struct IUOCallable {
+  static var callable: IUOCallable { IUOCallable() }
+  func callAsFunction(_ x: Int) -> IUOCallable! { nil }
+}
+
+func testIUOCallAsFunction(_ x: IUOCallable) {
+  let _: IUOCallable = x(5)
+  let _: IUOCallable? = x(5)
+  let _ = x(5)
+
+  let _: IUOCallable = .callable(5)
+  let _: IUOCallable? = .callable(5)
+}