[sending] Implement non-protocol function subtyping rules.

rdar://127675288

Author: gottesmm

lib/Sema/CSSimplify.cpp

@@ -3235,6 +3235,12 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
       return getTypeMatchFailure(locator);
   }
 
+  // () -> sending T can be a subtype of () -> T... but not vis-a-versa.
+  if (func1->hasSendingResult() != func2->hasSendingResult() &&
+      (!func1->hasSendingResult() || kind < ConstraintKind::Subtype)) {
+    return getTypeMatchFailure(locator);
+  }
+
   if (!matchFunctionIsolations(func1, func2, kind, flags, locator))
     return getTypeMatchFailure(locator);
 
@@ -3665,6 +3671,13 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
         return getTypeMatchFailure(argumentLocator);
       }
 
+      // Do not allow for functions that expect a sending parameter to match
+      // with a function that expects a non-sending parameter.
+      if (func1Param.getParameterFlags().isSending() &&
+          !func2Param.getParameterFlags().isSending()) {
+        return getTypeMatchFailure(argumentLocator);
+      }
+
       // FIXME: We should check value ownership too, but it's not completely
       // trivial because of inout-to-pointer conversions.
 

test/Concurrency/transfernonsendable_functionsubtyping.swift

@@ -22,9 +22,57 @@ protocol ProtocolWithMixedReqs {
   func nonSendingParamAndSendingResult(_ x: NonSendableKlass) -> sending NonSendableKlass // expected-note 4{{}}
 }
 
-/////////////////
-// MARK: Tests //
-/////////////////
+/////////////////////////////////
+// MARK: Normal Function Tests //
+/////////////////////////////////
+
+func functionWithSendingResult() -> sending NonSendableKlass { fatalError() }
+func functionWithoutSendingResult() -> NonSendableKlass { fatalError() }
+func functionWithSendingParameter(_ x: sending NonSendableKlass)  { fatalError() }
+func functionWithoutSendingParameter(_ x: NonSendableKlass)  { fatalError() }
+
+func takeFnWithSendingResult(_ fn: () -> sending NonSendableKlass) {}
+func takeFnWithoutSendingResult(_ fn: () -> NonSendableKlass) {}
+func takeFnWithSendingParam(_ fn: (sending NonSendableKlass) -> ()) {}
+func takeFnWithoutSendingParam(_ fn: (NonSendableKlass) -> ()) {}
+
+func testFunctionMatching() {
+  let _: (NonSendableKlass) -> () = functionWithSendingParameter
+  // expected-error @-1 {{cannot convert value of type '@Sendable (sending NonSendableKlass) -> ()' to specified type '(NonSendableKlass) -> ()'}}
+  let _: (sending NonSendableKlass) -> () = functionWithSendingParameter
+
+  let _: (NonSendableKlass) -> () = functionWithoutSendingParameter
+  let _: (sending NonSendableKlass) -> () = functionWithoutSendingParameter
+
+  takeFnWithSendingParam(functionWithSendingParameter)
+  takeFnWithoutSendingParam(functionWithSendingParameter)
+  // expected-error @-1 {{@Sendable (sending NonSendableKlass) -> ()' to expected argument type '(NonSendableKlass) -> ()}}
+  takeFnWithSendingParam(functionWithoutSendingParameter)
+  takeFnWithoutSendingParam(functionWithoutSendingParameter)
+}
+
+func testReturnValueMatching() {
+  let _: () -> NonSendableKlass = functionWithSendingResult
+  let _: () -> sending NonSendableKlass = functionWithSendingResult
+  let _: () -> NonSendableKlass = functionWithoutSendingResult
+  let _: () -> sending NonSendableKlass = functionWithoutSendingResult
+  // expected-error @-1 {{cannot convert value of type '@Sendable () -> NonSendableKlass' to specified type '() -> sending NonSendableKlass'}}
+
+  takeFnWithSendingResult(functionWithSendingResult)
+  takeFnWithSendingResult(functionWithoutSendingResult)
+  // expected-error @-1 {{cannot convert value of type '@Sendable () -> NonSendableKlass' to expected argument type '() -> sending NonSendableKlass'}}
+  let x: () -> NonSendableKlass = { fatalError() }
+  takeFnWithSendingResult(x)
+  // expected-error @-1 {{cannot convert value of type '() -> NonSendableKlass' to expected argument type '() -> sending NonSendableKlass'}}
+
+  takeFnWithoutSendingResult(functionWithSendingResult)
+  takeFnWithoutSendingResult(functionWithoutSendingResult)
+  takeFnWithoutSendingResult(x)
+}
+
+//////////////////////////
+// MARK: Protocol Tests //
+//////////////////////////
 
 struct MatchSuccess : ProtocolWithSendingReqs, ProtocolWithMixedReqs {
   func sendingResult() -> sending NonSendableKlass { fatalError() }