[region-isolation] Convert the typed strongly transferred value diagnostic into a short error, longer note diagnostic.

Just finishing these diagnostics.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -948,9 +948,6 @@ ERROR(regionbasedisolation_unknown_pattern, none,
 // Old Transfer Non Sendable Diagnostics
 //
 
-ERROR(regionbasedisolation_transfer_yields_race_stronglytransferred_binding, none,
-      "value of non-Sendable type %0 accessed after being transferred; later accesses could race",
-      (Type))
 ERROR(regionbasedisolation_arg_transferred, none,
       "sending %0 value of type %1 with later accesses to %2 context risks causing data races",
       (StringRef, Type, ActorIsolation))
@@ -1037,6 +1034,13 @@ NOTE(regionbasedisolation_named_transfer_nt_asynclet_capture, none,
       "sending %1 %0 into async let risks causing data races between nonisolated and %1 uses",
       (Identifier, StringRef))
 
+NOTE(regionbasedisolation_typed_use_after_sending, none,
+      "Passing value of non-Sendable type %0 as a 'sending' argument risks causing races in between local and caller code",
+      (Type))
+NOTE(regionbasedisolation_typed_use_after_sending_callee, none,
+      "Passing value of non-Sendable type %0 as a 'sending' argument to %1 %2 risks causing races in between local and caller code",
+      (Type, DescriptiveDeclKind, DeclName))
+
 // Misc Error.
 ERROR(regionbasedisolation_task_or_actor_isolated_transferred, none,
       "task or actor isolated value cannot be sent", ())

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -739,13 +739,17 @@ class UseAfterTransferDiagnosticEmitter {
 
   void emitTypedUseOfStronglyTransferredValue(SILLocation loc,
                                               Type inferredType) {
-    diagnoseError(
-        loc,
-        diag::
-            regionbasedisolation_transfer_yields_race_stronglytransferred_binding,
-        inferredType)
-        .highlight(loc.getSourceRange())
+    diagnoseError(loc, diag::regionbasedisolation_type_transfer_yields_race,
+                  inferredType)
         .limitBehaviorIf(getBehaviorLimit());
+    if (auto calleeInfo = getTransferringCalleeInfo()) {
+      diagnoseNote(loc,
+                   diag::regionbasedisolation_typed_use_after_sending_callee,
+                   inferredType, calleeInfo->first, calleeInfo->second);
+    } else {
+      diagnoseNote(loc, diag::regionbasedisolation_typed_use_after_sending,
+                   inferredType);
+    }
     emitRequireInstDiagnostics();
   }
 
@@ -1108,9 +1112,18 @@ void UseAfterTransferDiagnosticInferrer::infer() {
             baseLoc, rootValueAndName->first);
       }
 
+      // See if we have an ApplyExpr and if we can infer a better type.
+      Type type = baseInferredType;
+      if (auto *applyExpr =
+              transferOp->getUser()->getLoc().getAsASTNode<ApplyExpr>()) {
+        if (auto *foundExpr =
+                inferArgumentExprFromApplyExpr(applyExpr, fas, transferOp))
+          type = foundExpr->findOriginalType();
+      }
+
       // Otherwise, emit the typed diagnostic.
-      return diagnosticEmitter.emitTypedUseOfStronglyTransferredValue(
-          baseLoc, baseInferredType);
+      return diagnosticEmitter.emitTypedUseOfStronglyTransferredValue(baseLoc,
+                                                                      type);
     }
   }
 

test/Concurrency/transfernonsendable.swift

@@ -1762,7 +1762,8 @@ extension MyActor {
         _ = self
         _ = sc
 
-        Task { // expected-tns-warning {{value of non-Sendable type '@isolated(any) @async @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <()>' accessed after being transferred}}
+        Task { // expected-tns-warning {{sending value of non-Sendable type '() async -> ()' risks causing data races}}
+          // expected-tns-note @-1 {{Passing value of non-Sendable type '() async -> ()' as a 'sending' argument risks causing races in between local and caller code}}
           _ = sc
         }
 

test/Concurrency/transfernonsendable_typed_errors.swift

@@ -17,6 +17,8 @@
 
 class NonSendableKlass {}
 
+actor MyActor {}
+
 @MainActor func transferToMain<T>(_ t: T) async {}
 
 /////////////////
@@ -38,3 +40,34 @@ func isolatedClosureTest() async {
   }
   print(x) // expected-note {{access can happen concurrently}}
 }
+
+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}}
+  print(x) // expected-note {{access can happen concurrently}}
+}
+
+extension MyActor {
+  func testNonSendableCaptures(sc: NonSendableKlass) {
+    Task {
+      _ = self
+      _ = sc
+
+      Task { [sc,self] in
+        _ = self
+        _ = sc
+
+        Task { // expected-error {{sending value of non-Sendable type '() async -> ()' risks causing data races}}
+          // expected-note @-1 {{Passing value of non-Sendable type '() async -> ()' as a 'sending' argument risks causing races in between local and caller code}}
+          _ = sc
+        }
+
+        Task { // expected-note {{access can happen concurrently}}
+          _ = sc
+        }
+      }
+    }
+  }
+}