[CS] Resolve callees for implicit callAsFunction

Add a case to getCalleeLocator to return the
appropriate locator for a call to an implicit
callAsFunction member reference.

Resolves SR-11386 & SR-11778.

Author: hamishknight

lib/Sema/CSSimplify.cpp

@@ -7342,6 +7342,8 @@ ConstraintSystem::simplifyApplicableFnConstraint(
     auto memberTy = createTypeVariable(memberLoc, /*options=*/0);
     // TODO: Revisit this if `static func callAsFunction` is to be supported.
     // Static member constraint requires `FunctionRefKind::DoubleApply`.
+    // TODO: Use a custom locator element to identify this member constraint
+    // instead of just pointing to the function expr.
     addValueMemberConstraint(origLValueType2, DeclName(ctx.Id_callAsFunction),
                              memberTy, DC, FunctionRefKind::SingleApply,
                              /*outerAlternatives*/ {}, locator);

lib/Sema/ConstraintSystem.cpp

@@ -478,17 +478,29 @@ ConstraintSystem::getCalleeLocator(ConstraintLocator *locator,
   if (lookThroughApply) {
     if (auto *applyExpr = dyn_cast<ApplyExpr>(anchor)) {
       auto *fnExpr = applyExpr->getFn();
+
+      // FIXME: We should probably assert that we don't get a type variable
+      // here to make sure we only retrieve callee locators for resolved calls,
+      // ensuring that callee locators don't change after binding a type.
+      // Unfortunately CSDiag currently calls into getCalleeLocator, so all bets
+      // are off. Once we remove that legacy diagnostic logic, we should be able
+      // to assert here.
+      auto fnTy = getFixedTypeRecursive(getType(fnExpr), /*wantRValue*/ true);
+
       // For an apply of a metatype, we have a short-form constructor. Unlike
       // other locators to callees, these are anchored on the apply expression
       // rather than the function expr.
-      auto fnTy = getFixedTypeRecursive(getType(fnExpr), /*wantRValue*/ true);
       if (fnTy->is<AnyMetatypeType>()) {
         auto *fnLocator =
             getConstraintLocator(applyExpr, ConstraintLocator::ApplyFunction);
         return getConstraintLocator(fnLocator,
                                     ConstraintLocator::ConstructorMember);
       }
 
+      // Handle an apply of a nominal type which supports callAsFunction.
+      if (fnTy->isCallableNominalType(DC))
+        return getConstraintLocator(anchor, ConstraintLocator::ApplyFunction);
+
       // Otherwise fall through and look for locators anchored on the function
       // expr. For CallExprs, this can look through things like parens and
       // optional chaining.

test/SILGen/default_arguments.swift

@@ -408,3 +408,26 @@ func genericMagic<T : ExpressibleByStringLiteral>(x: T = #file) -> T {
 }
 
 let _: String = genericMagic()
+
+// SR-11778
+struct CallableWithDefault {
+  func callAsFunction(x: Int = 4) {}
+  func callAsFunction(y: Int, z: String = #function) {}
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s17default_arguments23testCallableWithDefaultyyAA0deF0VF : $@convention(thin) (CallableWithDefault) -> ()
+func testCallableWithDefault(_ x: CallableWithDefault) {
+  // CHECK: [[DEF_FN:%[0-9]+]] = function_ref @$s17default_arguments19CallableWithDefaultV14callAsFunction1xySi_tFfA_ : $@convention(thin) () -> Int
+  // CHECK: [[DEF:%[0-9]+]] = apply [[DEF_FN]]() : $@convention(thin) () -> Int
+  // CHECK: [[CALL_AS_FN:%[0-9]+]] = function_ref @$s17default_arguments19CallableWithDefaultV14callAsFunction1xySi_tF : $@convention(method) (Int, CallableWithDefault) -> ()
+  // CHECK: apply [[CALL_AS_FN]]([[DEF]], {{%[0-9]+}})
+  x()
+
+  // CHECK: [[RAW_I:%[0-9]+]] = integer_literal $Builtin.IntLiteral, 5
+  // CHECK: [[I:%[0-9]+]] = apply {{%[0-9]+}}([[RAW_I]], {{%[0-9]+}}) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
+  // CHECK: [[RAW_STR:%[0-9]+]] = string_literal utf8 "testCallableWithDefault(_:)"
+  // CHECK: [[STR:%[0-9]+]] = apply {{%[0-9]+}}([[RAW_STR]], {{%[0-9]+}}, {{%[0-9]+}}, {{%[0-9]+}}) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String
+  // CHECK: [[CALL_AS_FN:%[0-9]+]] = function_ref @$s17default_arguments19CallableWithDefaultV14callAsFunction1y1zySi_SStF : $@convention(method) (Int, @guaranteed String, CallableWithDefault) -> ()
+  // CHECK: apply [[CALL_AS_FN]]([[I]], [[STR]], {{%[0-9]+}})
+  x(y: 5)
+}

test/Sema/call_as_function_generic.swift

@@ -41,3 +41,19 @@ let genericString = GenericType<[String]>(collection: ["Hello", "world", "!"])
 _ = genericString("Hello")
 let genericInt = GenericType<Set<Int>>(collection: [1, 2, 3])
 _ = genericInt(initialValue: 1)
+
+// SR-11386
+class C<T> {}
+protocol P1 {}
+extension C where T : P1 { // expected-note {{where 'T' = 'Int'}}
+  func callAsFunction(t: T) {}
+}
+
+struct S0 : P1 {}
+
+func testCallAsFunctionWithWhereClause(_ c1: C<Int>, _ c2: C<S0>, _ s0: S0) {
+  c1(42) // expected-error {{referencing instance method 'callAsFunction(t:)' on 'C' requires that 'Int' conform to 'P1'}}
+  // expected-error@-1 {{missing argument label 't:' in call}}
+
+  c2(t: s0) // Okay.
+}

test/Sema/call_as_function_simple.swift

@@ -192,3 +192,15 @@ func testIUO(a: SimpleCallable!, b: MultipleArgsCallable!, c: Extended!,
   _ = try? h()
   _ = try? h { throw DummyError() }
 }
+
+// SR-11778
+struct DoubleANumber {
+  func callAsFunction(_ x: Int, completion: (Int) -> Void = { _ in }) {
+    completion(x + x)
+  }
+}
+
+func testDefaults(_ x: DoubleANumber) {
+  x(5)
+  x(5, completion: { _ in })
+}