[region-isolation] Emit a standard short warning + long note when emitting a strongly transferring a structurally isolated value warning.

Specifically, instead of what I call an IsolationRegionInfo + Type error, e.x.:

> task-isolated value of type 'NonSendableType' passed as a strongly transferred parameter; later accesses could race

we use instead the standard warning of:

```swift
func transfer(_ x: transferring Type) {}

func test(_ x: Type) {
  transfer(x) // expected-warning {{transferring 'x' may cause a race}}
  // expected-note @-1 {{task-isolated 'x' is passed as a transferring parameter; Uses in callee may race with later task-isolated uses}}
}
```

Implementation wise, I left in the old type diagnostic as a backup for now. With
time, I am going to want to eliminate it completely.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -957,8 +957,8 @@ ERROR(regionbasedisolation_arg_transferred, none,
       "%0 value of type %1 transferred to %2 context; later accesses to value could race",
       (StringRef, Type, ActorIsolation))
 ERROR(regionbasedisolation_arg_passed_to_strongly_transferred_param, none,
-      "task-isolated value of type %0 passed as a strongly transferred parameter; later accesses could race",
-      (Type))
+      "%0 value of type %1 passed as a strongly transferred parameter; later accesses could race",
+      (StringRef, Type))
 NOTE(regionbasedisolation_isolated_since_in_same_region_basename, none,
      "value is %0 since it is in the same region as %1",
      (StringRef, DeclBaseName))
@@ -973,9 +973,9 @@ ERROR(regionbasedisolation_named_transfer_yields_race, none,
 ERROR(regionbasedisolation_stronglytransfer_assignment_yields_race_name, none,
       "assigning %0 to transferring parameter %1 may cause a race",
       (Identifier, Identifier))
-NOTE(regionbasedisolation_stronglytransfer_taskisolated_assign_note, none,
-      "%0 is a task-isolated value that is assigned into transferring parameter %1. Transferred uses of %1 may race with caller uses of %0",
-      (Identifier, Identifier))
+NOTE(regionbasedisolation_named_transfer_into_transferring_param, none,
+      "%0 %1 is passed as a transferring parameter; Uses in callee may race with later %0 uses",
+      (StringRef, Identifier))
 
 NOTE(regionbasedisolation_named_info_transfer_yields_race, none,
      "%0 is transferred from %1 caller to %2 callee. Later uses in caller could race with potential uses in callee",
@@ -991,6 +991,12 @@ NOTE(regionbasedisolation_named_arg_info, none,
      (Identifier))
 NOTE(regionbasedisolation_named_stronglytransferred_binding, none,
      "Cannot access a transferring parameter after the parameter has been transferred", ())
+NOTE(regionbasedisolation_note_arg_passed_to_strongly_transferred_param, none,
+     "%0 value of type %1 passed as a strongly transferred parameter; later accesses could race",
+     (StringRef, Identifier, Type))
+ERROR(regionbasedisolation_named_arg_passed_to_strongly_transferred_param, none,
+      "%0 %1 passed as a strongly transferred parameter; Uses in callee could race with later %0 uses",
+      (StringRef, Identifier))
 
 // TODO: print the name of the nominal type
 ERROR(deinit_not_visible, none,

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -917,19 +917,18 @@ class TransferNonTransferrableDiagnosticEmitter {
   }
 
   void emitFunctionArgumentApply(SILLocation loc, Type type,
-                                 ValueIsolationRegionInfo regionInfo,
                                  ApplyIsolationCrossing crossing) {
     SmallString<64> descriptiveKindStr;
     {
       llvm::raw_svector_ostream os(descriptiveKindStr);
-      regionInfo.printForDiagnostics(os);
+      getIsolationRegionInfo().printForDiagnostics(os);
     }
     diagnoseError(loc, diag::regionbasedisolation_arg_transferred,
                   StringRef(descriptiveKindStr), type,
                   crossing.getCalleeIsolation())
         .highlight(getOperand()->getUser()->getLoc().getSourceRange());
 
-    if (regionInfo.isTaskIsolated()) {
+    if (getIsolationRegionInfo().isTaskIsolated()) {
       auto *fArg =
           cast<SILFunctionArgument>(info.nonTransferrable.get<SILValue>());
       if (fArg->getDecl()) {
@@ -964,23 +963,46 @@ class TransferNonTransferrableDiagnosticEmitter {
 
   void emitFunctionArgumentApplyStronglyTransferred(SILLocation loc,
                                                     Type type) {
-    diagnoseError(
-        loc,
-        diag::regionbasedisolation_arg_passed_to_strongly_transferred_param,
-        type)
+    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());
+  }
+
+  void emitNamedOnlyError(SILLocation loc, Identifier name) {
+    diagnoseError(loc, diag::regionbasedisolation_named_transfer_yields_race,
+                  name)
         .highlight(getOperand()->getUser()->getLoc().getSourceRange());
   }
 
   void emitNamedIsolation(SILLocation loc, Identifier name,
                           ApplyIsolationCrossing isolationCrossing) {
-    diagnoseError(loc, diag::regionbasedisolation_named_transfer_yields_race,
-                  name);
+    emitNamedOnlyError(loc, name);
     diagnoseNote(
         loc, diag::regionbasedisolation_transfer_non_transferrable_named_note,
         name, isolationCrossing.getCallerIsolation(),
         isolationCrossing.getCalleeIsolation());
   }
 
+  void emitNamedFunctionArgumentApplyStronglyTransferred(
+      SILLocation loc, Identifier varName,
+      ValueIsolationRegionInfo isolationRegionInfo) {
+    emitNamedOnlyError(loc, varName);
+    SmallString<64> descriptiveKindStr;
+    {
+      llvm::raw_svector_ostream os(descriptiveKindStr);
+      getIsolationRegionInfo().printForDiagnostics(os);
+    }
+    auto diag =
+        diag::regionbasedisolation_named_transfer_into_transferring_param;
+    diagnoseNote(loc, diag, descriptiveKindStr, varName);
+  }
+
 private:
   ASTContext &getASTContext() const {
     return getOperand()->getFunction()->getASTContext();
@@ -1073,29 +1095,35 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
   auto loc = op->getUser()->getLoc();
 
   if (auto *sourceApply = loc.getAsASTNode<ApplyExpr>()) {
-    std::optional<ApplyIsolationCrossing> isolation = {};
+    // First see if we have a transferring argument.
+    if (auto fas = FullApplySite::isa(op->getUser())) {
+      if (fas.getArgumentParameterInfo(*op).hasOption(
+              SILParameterInfo::Transferring)) {
+
+        // See if we can infer a name from the value.
+        SmallString<64> resultingName;
+        if (auto varName = inferNameFromValue(op->get())) {
+          diagnosticEmitter.emitNamedFunctionArgumentApplyStronglyTransferred(
+              loc, *varName, diagnosticEmitter.getIsolationRegionInfo());
+          return true;
+        }
+
+        Type type = op->get()->getType().getASTType();
+        if (auto *inferredArgExpr =
+                inferArgumentExprFromApplyExpr(sourceApply, fas, op)) {
+          type = inferredArgExpr->findOriginalType();
+        }
+        diagnosticEmitter.emitFunctionArgumentApplyStronglyTransferred(loc,
+                                                                       type);
+        return true;
+      }
+    }
 
     // First try to get the apply from the isolation crossing.
-    if (auto value = sourceApply->getIsolationCrossing())
-      isolation = value;
+    auto isolation = sourceApply->getIsolationCrossing();
 
     // If we could not infer an isolation...
     if (!isolation) {
-      // First see if we have a transferring argument.
-      if (auto fas = FullApplySite::isa(op->getUser())) {
-        if (fas.getArgumentParameterInfo(*op).hasOption(
-                SILParameterInfo::Transferring)) {
-          Type type = op->get()->getType().getASTType();
-          if (auto *inferredArgExpr =
-              inferArgumentExprFromApplyExpr(sourceApply, fas, op)) {
-            type = inferredArgExpr->findOriginalType();
-          }
-          diagnosticEmitter.emitFunctionArgumentApplyStronglyTransferred(loc,
-                                                                         type);
-          return true;
-        }
-      }
-
       // Otherwise, emit a "we don't know error" that tells the user to file a
       // bug.
       diagnoseError(op->getUser(), diag::regionbasedisolation_unknown_pattern);
@@ -1120,9 +1148,7 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
       }
     }
 
-    auto isolationRegionInfo = diagnosticEmitter.getIsolationRegionInfo();
-    diagnosticEmitter.emitFunctionArgumentApply(loc, type, isolationRegionInfo,
-                                                *isolation);
+    diagnosticEmitter.emitFunctionArgumentApply(loc, type, *isolation);
     return true;
   }
 
@@ -1137,10 +1163,8 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
   // See if we are in SIL and have an apply site specified isolation.
   if (auto fas = FullApplySite::isa(op->getUser())) {
     if (auto isolation = fas.getIsolationCrossing()) {
-      auto isolationRegionInfo = diagnosticEmitter.getIsolationRegionInfo();
       diagnosticEmitter.emitFunctionArgumentApply(
-          loc, op->get()->getType().getASTType(), isolationRegionInfo,
-          *isolation);
+          loc, op->get()->getType().getASTType(), *isolation);
       return true;
     }
   }

test/Concurrency/transfernonsendable_strong_transferring_params.swift

@@ -333,10 +333,19 @@ func testTransferOtherParamTuple(_ x: transferring Klass, y: (Klass, Klass)) asy
   x = y.0
 }
 
-func useSugaredTypeNameWhenEmittingTaskIsolationError(_ x: @escaping @MainActor () async -> ()) {
+func taskIsolatedError(_ x: @escaping @MainActor () async -> ()) {
   func fakeInit(operation: transferring @escaping () async -> ()) {}
 
-  fakeInit(operation: x) // expected-warning {{task-isolated value of type '@MainActor () async -> ()' passed as a strongly transferred parameter}}
+  fakeInit(operation: x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{task-isolated 'x' is passed as a transferring parameter; Uses in callee may race with later task-isolated uses}}
+}
+
+@MainActor func actorIsolatedError(_ x: @escaping @MainActor () async -> ()) {
+  func fakeInit(operation: transferring @escaping () async -> ()) {}
+
+  // TODO: This needs to say actor-isolated.
+  fakeInit(operation: x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{task-isolated 'x' is passed as a transferring parameter; Uses in callee may race with later task-isolated uses}}
 }
 
 // Make sure we error here on only the second since x by being assigned a part
@@ -348,3 +357,9 @@ func testMergeWithTaskIsolated(_ x: transferring Klass, y: Klass) async {
   await transferToMain(x) // expected-warning {{transferring 'x' may cause a race}}
   // expected-note @-1 {{transferring nonisolated 'x' to main actor-isolated callee could cause races between main actor-isolated and nonisolated uses}}
 }
+
+@MainActor func testMergeWithActorIsolated(_ x: transferring Klass, y: Klass) async {
+  x = y
+  await transferToCustom(x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{transferring main actor-isolated 'x' to global actor 'CustomActor'-isolated callee could cause races between global actor 'CustomActor'-isolated and main actor-isolated uses}}
+}

test/Concurrency/transfernonsendable_warning_until_swift6.swift

@@ -29,7 +29,8 @@ func testTransferArgumentError(_ x: NonSendableType) async { // expected-note {{
 }
 
 func testPassArgumentAsTransferringParameter(_ x: NonSendableType) async {
-  transferValue(x) // expected-error {{task-isolated value of type 'NonSendableType' passed as a strongly transferred parameter; later accesses could race}}
+  transferValue(x) // expected-error {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{task-isolated 'x' is passed as a transferring parameter; Uses in callee may race with later task-isolated uses}}
 }
 
 func testAssignmentIntoTransferringParameter(_ x: transferring NonSendableType) async {