[region-isolation] Give a proper named error for passing a never transferring values as a transferring argument

This eliminates a bunch of "task or actor isolated value transferred".

I also deleted some dead code.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -968,34 +968,21 @@ NOTE(regionbasedisolation_isolated_since_in_same_region_basename, none,
 ERROR(regionbasedisolation_named_transfer_yields_race, none,
       "transferring %0 may cause a race",
       (Identifier))
-ERROR(regionbasedisolation_stronglytransfer_assignment_yields_race_name, none,
-      "assigning %0 to transferring parameter %1 may cause a race",
-      (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",
      (Identifier, ActorIsolation, ActorIsolation))
-NOTE(regionbasedisolation_transfer_non_transferrable_named_note, none,
+NOTE(regionbasedisolation_named_transfer_non_transferrable, none,
       "transferring %1 %0 to %2 callee could cause races between %2 and %1 uses",
       (Identifier, ActorIsolation, ActorIsolation))
-NOTE(regionbasedisolation_named_info_isolated_capture, none,
-     "%1 value %0 is captured by %2 closure. Later local uses could race",
-     (Identifier, ActorIsolation, ActorIsolation))
-NOTE(regionbasedisolation_named_arg_info, none,
-     "Transferring task-isolated function argument %0 could yield races with caller uses",
-     (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))
+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_notransfer_transfer_into_result, none,
+     "%0 %1 cannot be a transferring result. %0 uses may race with caller uses",
+     (StringRef, Identifier))
 
+// Misc Error.
 ERROR(regionbasedisolation_task_or_actor_isolated_transferred, none,
       "task or actor isolated value cannot be transferred", ())
 

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -985,15 +985,14 @@ class TransferNonTransferrableDiagnosticEmitter {
   void emitNamedIsolation(SILLocation loc, Identifier name,
                           ApplyIsolationCrossing isolationCrossing) {
     emitNamedOnlyError(loc, name);
-    diagnoseNote(
-        loc, diag::regionbasedisolation_transfer_non_transferrable_named_note,
-        name, isolationCrossing.getCallerIsolation(),
-        isolationCrossing.getCalleeIsolation());
+    diagnoseNote(loc,
+                 diag::regionbasedisolation_named_transfer_non_transferrable,
+                 name, isolationCrossing.getCallerIsolation(),
+                 isolationCrossing.getCalleeIsolation());
   }
 
-  void emitNamedFunctionArgumentApplyStronglyTransferred(
-      SILLocation loc, Identifier varName,
-      ValueIsolationRegionInfo isolationRegionInfo) {
+  void emitNamedFunctionArgumentApplyStronglyTransferred(SILLocation loc,
+                                                         Identifier varName) {
     emitNamedOnlyError(loc, varName);
     SmallString<64> descriptiveKindStr;
     {
@@ -1005,6 +1004,18 @@ class TransferNonTransferrableDiagnosticEmitter {
     diagnoseNote(loc, diag, descriptiveKindStr, varName);
   }
 
+  void emitNamedTransferringReturn(SILLocation loc, Identifier varName) {
+    emitNamedOnlyError(loc, varName);
+    SmallString<64> descriptiveKindStr;
+    {
+      llvm::raw_svector_ostream os(descriptiveKindStr);
+      getIsolationRegionInfo().printForDiagnostics(os);
+    }
+    auto diag =
+        diag::regionbasedisolation_named_notransfer_transfer_into_result;
+    diagnoseNote(loc, diag, descriptiveKindStr, varName);
+  }
+
 private:
   ASTContext &getASTContext() const {
     return getOperand()->getFunction()->getASTContext();
@@ -1106,7 +1117,7 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
         SmallString<64> resultingName;
         if (auto varName = inferNameFromValue(op->get())) {
           diagnosticEmitter.emitNamedFunctionArgumentApplyStronglyTransferred(
-              loc, *varName, diagnosticEmitter.getIsolationRegionInfo());
+              loc, *varName);
           return true;
         }
 
@@ -1171,6 +1182,33 @@ bool TransferNonTransferrableDiagnosticInferrer::run() {
     }
   }
 
+  if (auto *ri = dyn_cast<ReturnInst>(op->getUser())) {
+    auto fType = ri->getFunction()->getLoweredFunctionType();
+    if (fType->getNumResults() &&
+        fType->getResults()[0].hasOption(SILResultInfo::IsTransferring)) {
+      assert(llvm::all_of(fType->getResults(),
+                          [](SILResultInfo resultInfo) {
+                            return resultInfo.hasOption(
+                                SILResultInfo::IsTransferring);
+                          }) &&
+             "All result info must be the same... if that changes... update "
+             "this code!");
+      SmallString<64> resultingName;
+      if (auto name = inferNameFromValue(op->get())) {
+        diagnosticEmitter.emitNamedTransferringReturn(loc, *name);
+        return true;
+      }
+    } else {
+      assert(llvm::none_of(fType->getResults(),
+                           [](SILResultInfo resultInfo) {
+                             return resultInfo.hasOption(
+                                 SILResultInfo::IsTransferring);
+                           }) &&
+             "All result info must be the same... if that changes... update "
+             "this code!");
+    }
+  }
+
   diagnosticEmitter.emitUnknownUse(loc);
   return true;
 }

test/Concurrency/transfernonsendable.sil

@@ -222,23 +222,26 @@ bb0(%0 : @guaranteed $NonSendableStruct):
   debug_value %0 : $NonSendableStruct, var, name "myname"
   %2 = struct_extract %0 : $NonSendableStruct, #NonSendableStruct.ns
   %3 = copy_value %2 : $NonSendableKlass
-  return %3 : $NonSendableKlass // expected-warning {{task or actor isolated value cannot be transferred}}
+  return %3 : $NonSendableKlass // expected-warning {{transferring 'myname.ns' may cause a race}}
+  // expected-note @-1 {{task-isolated 'myname.ns' cannot be a transferring result. task-isolated uses may race with caller uses}}
 }
 
 sil [ossa] @synchronous_returns_transferring_globalactor_struct_structextract : $@convention(method) (@guaranteed MainActorIsolatedStruct) -> @sil_transferring @owned NonSendableKlass {
 bb0(%0 : @guaranteed $MainActorIsolatedStruct):
   debug_value %0 : $MainActorIsolatedStruct, var, name "myname"
   %2 = struct_extract %0 : $MainActorIsolatedStruct, #MainActorIsolatedStruct.ns
   %3 = copy_value %2 : $NonSendableKlass
-  return %3 : $NonSendableKlass // expected-warning {{task or actor isolated value cannot be transferred}}
+  return %3 : $NonSendableKlass // expected-warning {{transferring 'myname.ns' may cause a race}}
+  // expected-note @-1 {{main actor-isolated 'myname.ns' cannot be a transferring result. main actor-isolated uses may race with caller uses}}
 }
 
 sil [ossa] @synchronous_returns_transferring_globalactor_struct_structelementaddr : $@convention(method) (@in_guaranteed MainActorIsolatedStruct) -> @sil_transferring @owned NonSendableKlass {
 bb0(%0 : $*MainActorIsolatedStruct):
   debug_value %0 : $*MainActorIsolatedStruct, var, name "myname"
   %2 = struct_element_addr %0 : $*MainActorIsolatedStruct, #MainActorIsolatedStruct.ns
   %3 = load [copy] %2 : $*NonSendableKlass
-  return %3 : $NonSendableKlass // expected-warning {{task or actor isolated value cannot be transferred}}
+  return %3 : $NonSendableKlass // expected-warning {{transferring 'myname.ns' may cause a race}}
+  // expected-note @-1 {{main actor-isolated 'myname.ns' cannot be a transferring result. main actor-isolated uses may race with caller uses}}
 }
 
 sil [ossa] @synchronous_returns_transferring_globalactor_enum_uncheckedenumdata : $@convention(method) (@guaranteed MainActorIsolatedEnum) -> @sil_transferring @owned NonSendableKlass {

test/Concurrency/transfernonsendable_strong_transferring_results.swift

@@ -110,7 +110,14 @@ func transferInAndOut(_ x: transferring NonSendableKlass) -> transferring NonSen
 
 
 func transferReturnArg(_ x: NonSendableKlass) -> transferring NonSendableKlass {
-  return x // expected-warning {{task or actor isolated value cannot be transferred}}
+  return x // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{task-isolated 'x' cannot be a transferring result. task-isolated uses may race with caller uses}}
+}
+
+// TODO: This will be fixed once I represent @MainActor on func types.
+@MainActor func transferReturnArgMainActor(_ x: NonSendableKlass) -> transferring NonSendableKlass {
+  return x // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{task-isolated 'x' cannot be a transferring result. task-isolated uses may race with caller uses}}
 }
 
 // This is safe since we are returning the whole tuple fresh. In contrast,
@@ -130,7 +137,8 @@ func useTransferredResult() async {
 
 extension MainActorIsolatedStruct {
   func testNonSendableErrorReturnWithTransfer() -> transferring NonSendableKlass {
-    return ns // expected-warning {{task or actor isolated value cannot be transferred}}
+    return ns // expected-warning {{transferring 'self.ns' may cause a race}}
+    // expected-note @-1 {{main actor-isolated 'self.ns' cannot be a transferring result. main actor-isolated uses may race with caller uses}}
   }
   func testNonSendableErrorReturnNoTransfer() -> NonSendableKlass {
     return ns