[region-isolation] Move from old style to new style the typed error for passing never sendable types as a sending parameter.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -951,9 +951,6 @@ ERROR(regionbasedisolation_unknown_pattern, none,
 ERROR(regionbasedisolation_arg_transferred, none,
       "sending %0 value of type %1 with later accesses to %2 context risks causing data races",
       (StringRef, Type, ActorIsolation))
-ERROR(regionbasedisolation_arg_passed_to_strongly_transferred_param, none,
-      "%0 value of type %1 passed as a strongly transferred parameter; later accesses could race",
-      (StringRef, Type))
 
 //===---
 // New Transfer Non Sendable Diagnostics
@@ -1029,6 +1026,12 @@ NOTE(regionbasedisolation_named_value_used_after_explicit_sending, none,
 NOTE(regionbasedisolation_named_isolated_closure_yields_race, none,
       "%0%1 is captured by a %2 closure. %2 uses in closure may race against later %3 uses",
       (StringRef, Identifier, ActorIsolation, ActorIsolation))
+NOTE(regionbasedisolation_typed_tns_passed_to_sending, none,
+     "Passing %0 value of non-Sendable type %1 as a 'sending' parameter risks causing races inbetween %0 uses and uses reachable from the callee",
+     (StringRef, Type))
+NOTE(regionbasedisolation_typed_tns_passed_to_sending_callee, none,
+     "Passing %0 value of non-Sendable type %1 as a 'sending' parameter to %2 %3 risks causing races inbetween %0 uses and uses reachable from %2",
+     (StringRef, Type, DescriptiveDeclKind, DeclName))
 
 NOTE(regionbasedisolation_named_transfer_nt_asynclet_capture, none,
       "sending %1 %0 into async let risks causing data races between nonisolated and %1 uses",

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -1346,18 +1346,28 @@ class TransferNonTransferrableDiagnosticEmitter {
         .highlight(loc.getSourceRange());
   }
 
-  void emitFunctionArgumentApplyStronglyTransferred(SILLocation loc,
-                                                    Type type) {
+  void emitTypedSendingNeverSendableToSendingParam(SILLocation loc,
+                                                   Type inferredType) {
+    diagnoseError(loc, diag::regionbasedisolation_type_transfer_yields_race,
+                  inferredType)
+        .highlight(loc.getSourceRange())
+        .limitBehaviorIf(getBehaviorLimit());
+
     SmallString<64> descriptiveKindStr;
     {
       llvm::raw_svector_ostream os(descriptiveKindStr);
       getIsolationRegionInfo().printForDiagnostics(os);
     }
-    auto diag =
-        diag::regionbasedisolation_arg_passed_to_strongly_transferred_param;
-    diagnoseError(loc, diag, descriptiveKindStr, type)
-        .highlight(getOperand()->getUser()->getLoc().getSourceRange())
-        .limitBehaviorIf(getBehaviorLimit());
+
+    if (auto calleeInfo = getTransferringCalleeInfo()) {
+      diagnoseNote(
+          loc, diag::regionbasedisolation_typed_tns_passed_to_sending_callee,
+          descriptiveKindStr, inferredType, calleeInfo->first,
+          calleeInfo->second);
+    } else {
+      diagnoseNote(loc, diag::regionbasedisolation_typed_tns_passed_to_sending,
+                   descriptiveKindStr, inferredType);
+    }
   }
 
   void emitNamedOnlyError(SILLocation loc, Identifier name) {
@@ -1415,8 +1425,8 @@ class TransferNonTransferrableDiagnosticEmitter {
     }
   }
 
-  void emitNamedFunctionArgumentApplyStronglyTransferred(SILLocation loc,
-                                                         Identifier varName) {
+  void emitNamedSendingNeverSendableToSendingParam(SILLocation loc,
+                                                   Identifier varName) {
     emitNamedOnlyError(loc, varName);
     SmallString<64> descriptiveKindStr;
     {
@@ -1631,7 +1641,7 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
         // See if we can infer a name from the value.
         SmallString<64> resultingName;
         if (auto varName = inferNameHelper(op->get())) {
-          diagnosticEmitter.emitNamedFunctionArgumentApplyStronglyTransferred(
+          diagnosticEmitter.emitNamedSendingNeverSendableToSendingParam(
               loc, *varName);
           return true;
         }
@@ -1641,8 +1651,8 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
                 inferArgumentExprFromApplyExpr(sourceApply, fas, op)) {
           type = inferredArgExpr->findOriginalType();
         }
-        diagnosticEmitter.emitFunctionArgumentApplyStronglyTransferred(loc,
-                                                                       type);
+        diagnosticEmitter.emitTypedSendingNeverSendableToSendingParam(loc,
+                                                                      type);
         return true;
       }
     }

test/Concurrency/transfernonsendable_typed_errors.swift

@@ -20,6 +20,7 @@ class NonSendableKlass {}
 actor MyActor {}
 
 @MainActor func transferToMain<T>(_ t: T) async {}
+func transferToSendingParam<T>(_ x: sending T) {}
 
 /////////////////
 // MARK: Tests //
@@ -42,10 +43,9 @@ func isolatedClosureTest() async {
 }
 
 func sendingError() async {
-  func test(_ x: sending NonSendableKlass) {}
   let x = NonSendableKlass()
-  test(x) // expected-error {{sending value of non-Sendable type 'NonSendableKlass' risks causing data races}}
-  // expected-note @-1 {{Passing value of non-Sendable type 'NonSendableKlass' as a 'sending' argument to local function 'test' risks causing races in between local and caller code}}
+  transferToSendingParam(x) // expected-error {{sending value of non-Sendable type 'NonSendableKlass' risks causing data races}}
+  // expected-note @-1 {{Passing value of non-Sendable type 'NonSendableKlass' as a 'sending' argument to global function 'transferToSendingParam' risks causing races in between local and callee code}}
   print(x) // expected-note {{access can happen concurrently}}
 }
 
@@ -71,3 +71,9 @@ extension MyActor {
     }
   }
 }
+
+@MainActor
+func sendingTransferNonSendableError(_ x: NonSendableKlass) {
+  transferToSendingParam(x) // expected-error {{sending value of non-Sendable type 'NonSendableKlass' risks causing data races}}
+  // expected-note @-1 {{Passing main actor-isolated value of non-Sendable type 'NonSendableKlass' as a 'sending' parameter to global function 'transferToSendingParam' risks causing races inbetween main actor-isolated uses and uses reachable from 'transferToSendingParam'}}
+}