[sending] Improve the sending mismatch errors and make them warnings when not in swift 6.

This will ensure that we do not break anyone who has adopted APIs like
CheckedContinuation.resume that now have sending parameters.

An example of where this can come up is shown by the ProcessType in SwiftToolsCore:

```swift
@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
@discardableResult
public func waitUntilExit() async throws -> ProcessResult {
    try await withCheckedThrowingContinuation { continuation in
        DispatchQueue.processConcurrent.async {
            self.waitUntilExit(continuation.resume(with:))
        }
    }
}
```

This fails to compile since self.waitUntilExit doesn't expect a function that
takes a sending parameter. We want to give people time to fix such issues.

Author: gottesmm

include/swift/AST/DiagnosticsSema.def

@@ -8012,6 +8012,19 @@ ERROR(sending_only_on_parameters_and_results, none,
       "'sending' may only be used on parameters and results", ())
 ERROR(sending_cannot_be_applied_to_tuple_elt, none,
       "'sending' cannot be applied to tuple elements", ())
+ERROR(sending_function_wrong_sending,none,
+      "converting a value of type %0 to type %1 risks causing data races",
+      (Type, Type))
+NOTE(sending_function_param_with_sending_param_note, none,
+     "converting a function typed value with a sending parameter to one "
+     "without risks allowing actor-isolated values to escape their isolation "
+     "domain as an argument to an invocation of value",
+     ())
+NOTE(sending_function_result_with_sending_param_note, none,
+     "converting a function typed value without a sending result as one with "
+     "risks allowing actor-isolated values to escape their "
+     "isolation domain through a result of an invocation of value",
+     ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Sema/CSFix.h

@@ -474,6 +474,17 @@ enum class FixKind : uint8_t {
   /// Ignore situations when key path subscript index gets passed an invalid
   /// type as an argument (something that is not a key path).
   IgnoreKeyPathSubscriptIndexMismatch,
+
+  /// Ignore the following situations:
+  ///
+  /// 1. Where we have a function that expects a function typed parameter
+  /// without a sendable parameter but is passed a function type with a sending
+  /// parameter.
+  ///
+  /// 2. Where we have a function that expects a function typed parameter with a
+  /// sending result, but is passed a function typeed parameter without a
+  /// sending result.
+  AllowSendingMismatch,
 };
 
 class ConstraintFix {
@@ -2648,6 +2659,49 @@ class TreatEphemeralAsNonEphemeral final : public AllowArgumentMismatch {
   }
 };
 
+/// Error if a user passes let f: (sending T) -> () as a (T) -> ().
+///
+/// This prevents data races since f assumes its parameter if the parameter is
+/// non-Sendable is safe to transfer onto other situations. The caller though
+/// that this is being sent to does not enforce that invariants within its body.
+class AllowSendingMismatch final : public ContextualMismatch {
+public:
+  enum class Kind {
+    Parameter,
+    Result,
+  };
+
+private:
+  Kind kind;
+
+  AllowSendingMismatch(ConstraintSystem &cs, Type argType, Type paramType,
+                       ConstraintLocator *locator, Kind kind,
+                       FixBehavior fixBehavior)
+      : ContextualMismatch(cs, FixKind::AllowSendingMismatch, argType,
+                           paramType, locator, fixBehavior),
+        kind(kind) {}
+
+public:
+  std::string getName() const override {
+    return "treat a function argument with sending parameter as a function "
+           "argument without sending parameters";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  static AllowSendingMismatch *create(ConstraintSystem &cs,
+                                      ConstraintLocator *locator, Type srcType,
+                                      Type dstType, Kind kind);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowSendingMismatch;
+  }
+};
+
 class SpecifyBaseTypeForContextualMember final : public ConstraintFix {
   DeclNameRef MemberName;
 

lib/Sema/CSDiagnostics.cpp

@@ -8020,6 +8020,24 @@ bool NonEphemeralConversionFailure::diagnoseAsError() {
   return true;
 }
 
+bool SendingOnFunctionParameterMismatchFail::diagnoseAsError() {
+  emitDiagnosticAt(getLoc(), diag::sending_function_wrong_sending,
+                   getFromType(), getToType())
+      .warnUntilSwiftVersion(6);
+  emitDiagnosticAt(getLoc(),
+                   diag::sending_function_param_with_sending_param_note);
+  return true;
+}
+
+bool SendingOnFunctionResultMismatchFailure::diagnoseAsError() {
+  emitDiagnosticAt(getLoc(), diag::sending_function_wrong_sending,
+                   getFromType(), getToType())
+      .warnUntilSwiftVersion(6);
+  emitDiagnosticAt(getLoc(),
+                   diag::sending_function_result_with_sending_param_note);
+  return true;
+}
+
 bool AssignmentTypeMismatchFailure::diagnoseMissingConformance() const {
   auto srcType = getFromType();
   auto dstType = getToType()->lookThroughAllOptionalTypes();

lib/Sema/CSDiagnostics.h

@@ -2306,6 +2306,28 @@ class NonEphemeralConversionFailure final : public ArgumentMismatchFailure {
   void emitSuggestionNotes() const;
 };
 
+class SendingOnFunctionParameterMismatchFail final : public ContextualFailure {
+public:
+  SendingOnFunctionParameterMismatchFail(const Solution &solution, Type srcType,
+                                         Type dstType,
+                                         ConstraintLocator *locator,
+                                         FixBehavior fixBehavior)
+      : ContextualFailure(solution, srcType, dstType, locator, fixBehavior) {}
+
+  bool diagnoseAsError() override;
+};
+
+class SendingOnFunctionResultMismatchFailure final : public ContextualFailure {
+public:
+  SendingOnFunctionResultMismatchFailure(const Solution &solution, Type srcType,
+                                         Type dstType,
+                                         ConstraintLocator *locator,
+                                         FixBehavior fixBehavior)
+      : ContextualFailure(solution, srcType, dstType, locator, fixBehavior) {}
+
+  bool diagnoseAsError() override;
+};
+
 class AssignmentTypeMismatchFailure final : public ContextualFailure {
 public:
   AssignmentTypeMismatchFailure(const Solution &solution,

lib/Sema/CSFix.cpp

@@ -1884,6 +1884,34 @@ std::string TreatEphemeralAsNonEphemeral::getName() const {
   return name;
 }
 
+bool AllowSendingMismatch::diagnose(const Solution &solution,
+                                    bool asNote) const {
+  switch (kind) {
+  case Kind::Parameter: {
+    SendingOnFunctionParameterMismatchFail failure(
+        solution, getFromType(), getToType(), getLocator(), fixBehavior);
+    return failure.diagnose(asNote);
+  }
+  case Kind::Result: {
+    SendingOnFunctionResultMismatchFailure failure(
+        solution, getFromType(), getToType(), getLocator(), fixBehavior);
+    return failure.diagnose(asNote);
+  }
+  }
+  llvm_unreachable("Covered switch isn't covered?!");
+}
+
+AllowSendingMismatch *AllowSendingMismatch::create(ConstraintSystem &cs,
+                                                   ConstraintLocator *locator,
+                                                   Type srcType, Type dstType,
+                                                   Kind kind) {
+  auto fixBehavior = cs.getASTContext().LangOpts.isSwiftVersionAtLeast(6)
+                         ? FixBehavior::Error
+                         : FixBehavior::DowngradeToWarning;
+  return new (cs.getAllocator())
+      AllowSendingMismatch(cs, srcType, dstType, locator, kind, fixBehavior);
+}
+
 bool SpecifyBaseTypeForContextualMember::diagnose(const Solution &solution,
                                                   bool asNote) const {
   MissingContextualBaseInMemberRefFailure failure(solution, MemberName,

lib/Sema/CSSimplify.cpp

@@ -3238,7 +3238,11 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   // () -> 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);
+    auto *fix = AllowSendingMismatch::create(
+        *this, getConstraintLocator(locator), func1, func2,
+        AllowSendingMismatch::Kind::Result);
+    if (recordFix(fix))
+      return getTypeMatchFailure(locator);
   }
 
   if (!matchFunctionIsolations(func1, func2, kind, flags, locator))
@@ -3675,7 +3679,11 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
       // with a function that expects a non-sending parameter.
       if (func1Param.getParameterFlags().isSending() &&
           !func2Param.getParameterFlags().isSending()) {
-        return getTypeMatchFailure(argumentLocator);
+        auto *fix = AllowSendingMismatch::create(
+            *this, getConstraintLocator(argumentLocator), func1, func2,
+            AllowSendingMismatch::Kind::Parameter);
+        if (recordFix(fix))
+          return getTypeMatchFailure(argumentLocator);
       }
 
       // FIXME: We should check value ownership too, but it's not completely
@@ -15144,6 +15152,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
     }
   }
 
+  case FixKind::AllowSendingMismatch:
   case FixKind::InsertCall:
   case FixKind::RemoveReturn:
   case FixKind::RemoveAddressOf:

test/Concurrency/transfernonsendable_functionsubtyping.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -swift-version 6 %s
+// RUN: %target-typecheck-verify-swift -swift-version 6
 
 // READ THIS! This file only contains tests that validate that the relevant
 // function subtyping rules for sending work. Please do not put other tests in
@@ -38,15 +38,17 @@ func takeFnWithoutSendingParam(_ fn: (NonSendableKlass) -> ()) {}
 
 func testFunctionMatching() {
   let _: (NonSendableKlass) -> () = functionWithSendingParameter
-  // expected-error @-1 {{cannot convert value of type '@Sendable (sending NonSendableKlass) -> ()' to specified type '(NonSendableKlass) -> ()'}}
+  // expected-error @-1 {{converting a value of type '@Sendable (sending NonSendableKlass) -> ()' to type '(NonSendableKlass) -> ()' risks causing data races}}
+  // expected-note @-2 {{converting a function typed value with a sending parameter to one without risks allowing actor-isolated values to escape their isolation domain as an argument to an invocation of value}}
   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) -> ()}}
+  // expected-error @-1 {{converting a value of type '@Sendable (sending NonSendableKlass) -> ()' to type '(NonSendableKlass) -> ()' risks causing data races}}
+  // expected-note @-2 {{converting a function typed value with a sending parameter to one without risks allowing actor-isolated values to escape their isolation domain as an argument to an invocation of value}}
   takeFnWithSendingParam(functionWithoutSendingParameter)
   takeFnWithoutSendingParam(functionWithoutSendingParameter)
 }
@@ -56,14 +58,17 @@ func testReturnValueMatching() {
   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'}}
+  // expected-error @-1 {{converting a value of type '@Sendable () -> NonSendableKlass' to type '() -> sending NonSendableKlass' risks causing data races}}
+  // expected-note @-2 {{converting a function typed value without a sending result as one with risks allowing actor-isolated values to escape their isolation domain through a result of an invocation of value}}
 
   takeFnWithSendingResult(functionWithSendingResult)
   takeFnWithSendingResult(functionWithoutSendingResult)
-  // expected-error @-1 {{cannot convert value of type '@Sendable () -> NonSendableKlass' to expected argument type '() -> sending NonSendableKlass'}}
+  // expected-error @-1 {{converting a value of type '@Sendable () -> NonSendableKlass' to type '() -> sending NonSendableKlass' risks causing data races}}
+  // expected-note @-2 {{converting a function typed value without a sending result as one with risks allowing actor-isolated values to escape their isolation domain through a result of an invocation of value}}
   let x: () -> NonSendableKlass = { fatalError() }
   takeFnWithSendingResult(x)
-  // expected-error @-1 {{cannot convert value of type '() -> NonSendableKlass' to expected argument type '() -> sending NonSendableKlass'}}
+  // expected-error @-1 {{converting a value of type '() -> NonSendableKlass' to type '() -> sending NonSendableKlass' risks causing data races}}
+  // expected-note @-2 {{converting a function typed value without a sending result as one with risks allowing actor-isolated values to escape their isolation domain through a result of an invocation of value}}
 
   takeFnWithoutSendingResult(functionWithSendingResult)
   takeFnWithoutSendingResult(functionWithoutSendingResult)