[region-isolation] Emit an error when we assign a non-disconnected value into a sending result.

rdar://127318392

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -972,6 +972,9 @@ ERROR(regionbasedisolation_arg_passed_to_strongly_transferred_param, none,
 ERROR(regionbasedisolation_named_transfer_yields_race, none,
       "sending %0 risks causing data races",
       (Identifier))
+NOTE(regionbasedisolation_type_is_non_sendable, none,
+      "%0 is a non-Sendable type",
+      (Type))
 
 ERROR(regionbasedisolation_inout_sending_cannot_be_actor_isolated, none,
       "'inout sending' parameter %0 cannot be %1at end of function",
@@ -980,6 +983,20 @@ NOTE(regionbasedisolation_inout_sending_cannot_be_actor_isolated_note, none,
       "%1%0 risks causing races in between %1uses and caller uses since caller assumes value is not actor isolated",
       (Identifier, StringRef))
 
+ERROR(regionbasedisolation_out_sending_cannot_be_actor_isolated_type, none,
+      "returning a %1 %0 value as a 'sending' result risks causing data races",
+      (Type, StringRef))
+NOTE(regionbasedisolation_out_sending_cannot_be_actor_isolated_note_type, none,
+      "returning a %1 %0 value risks causing races since the caller assumes the value can be safely sent to other isolation domains",
+      (Type, StringRef))
+
+ERROR(regionbasedisolation_out_sending_cannot_be_actor_isolated_named, none,
+      "returning %1 %0 as a 'sending' result risks causing data races",
+      (Identifier, StringRef))
+NOTE(regionbasedisolation_out_sending_cannot_be_actor_isolated_note_named, none,
+      "returning %1 %0 risks causing data races since the caller assumes that %0 can be safely sent to other isolation domains",
+      (Identifier, StringRef))
+
 NOTE(regionbasedisolation_named_info_transfer_yields_race, none,
      "sending %1%0 to %2 callee risks causing data races between %2 and local %3 uses",
      (Identifier, StringRef, ActorIsolation, ActorIsolation))

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -996,6 +996,16 @@ struct PartitionOpEvaluator {
                                                    isolationRegionInfo);
   }
 
+  /// Just call our CRTP subclass.
+  void handleAssignTransferNonTransferrableIntoSendingResult(
+      const PartitionOp &op, Element destElement,
+      SILFunctionArgument *destValue, Element srcElement, SILValue srcValue,
+      SILDynamicMergedIsolationInfo srcIsolationRegionInfo) const {
+    return asImpl().handleAssignTransferNonTransferrableIntoSendingResult(
+        op, destElement, destValue, srcElement, srcValue,
+        srcIsolationRegionInfo);
+  }
+
   /// Call our CRTP subclass.
   void handleInOutSendingNotInitializedAtExitError(
       const PartitionOp &op, Element elt, Operand *transferringOp) const {
@@ -1112,13 +1122,41 @@ struct PartitionOpEvaluator {
     p.pushHistorySequenceBoundary(loc);
 
     switch (op.getKind()) {
-    case PartitionOpKind::Assign:
+    case PartitionOpKind::Assign: {
       assert(op.getOpArgs().size() == 2 &&
              "Assign PartitionOp should be passed 2 arguments");
       assert(p.isTrackingElement(op.getOpArgs()[1]) &&
              "Assign PartitionOp's source argument should be already tracked");
+
+      // See if we are assigning an a non-disconnected value into a 'out
+      // sending' parameter. In such a case, we emit a diagnostic.
+      if (op.getSourceInst()
+              ->getFunction()
+              ->getLoweredFunctionType()
+              ->hasSendingResult()) {
+        if (auto instance = getRepresentativeValue(op.getOpArgs()[0])) {
+          if (auto value = instance.maybeGetValue()) {
+            if (auto *fArg = dyn_cast<SILFunctionArgument>(value)) {
+              if (fArg->getArgumentConvention().isIndirectOutParameter()) {
+                Region srcRegion = p.getRegion(op.getOpArgs()[1]);
+                auto dynamicRegionIsolation = getIsolationRegionInfo(srcRegion);
+                // We can unconditionally getValue here since we can never
+                // assign an actor introducing inst.
+                auto rep = getRepresentativeValue(op.getOpArgs()[1]).getValue();
+                if (!dynamicRegionIsolation.isDisconnected()) {
+                  handleAssignTransferNonTransferrableIntoSendingResult(
+                      op, op.getOpArgs()[0], fArg, op.getOpArgs()[1], rep,
+                      dynamicRegionIsolation);
+                }
+              }
+            }
+          }
+        }
+      }
+
       p.assignElement(op.getOpArgs()[0], op.getOpArgs()[1]);
       return;
+    }
     case PartitionOpKind::AssignFresh:
       assert(op.getOpArgs().size() == 1 &&
              "AssignFresh PartitionOp should be passed 1 argument");
@@ -1199,15 +1237,42 @@ struct PartitionOpEvaluator {
       p.undoTransfer(op.getOpArgs()[0]);
       return;
     }
-    case PartitionOpKind::Merge:
+    case PartitionOpKind::Merge: {
       assert(op.getOpArgs().size() == 2 &&
              "Merge PartitionOp should be passed 2 arguments");
       assert(p.isTrackingElement(op.getOpArgs()[0]) &&
              p.isTrackingElement(op.getOpArgs()[1]) &&
              "Merge PartitionOp's arguments should already be tracked");
 
+      // See if we are assigning an a non-disconnected value into a 'out
+      // sending' parameter. In such a case, we emit a diagnostic.
+      if (op.getSourceInst()
+              ->getFunction()
+              ->getLoweredFunctionType()
+              ->hasSendingResult()) {
+        if (auto instance = getRepresentativeValue(op.getOpArgs()[0])) {
+          if (auto value = instance.maybeGetValue()) {
+            if (auto *fArg = dyn_cast<SILFunctionArgument>(value)) {
+              if (fArg->getArgumentConvention().isIndirectOutParameter()) {
+                Region srcRegion = p.getRegion(op.getOpArgs()[1]);
+                auto dynamicRegionIsolation = getIsolationRegionInfo(srcRegion);
+                // We can unconditionally getValue here since we can never
+                // assign an actor introducing inst.
+                auto rep = getRepresentativeValue(op.getOpArgs()[1]).getValue();
+                if (!dynamicRegionIsolation.isDisconnected()) {
+                  handleAssignTransferNonTransferrableIntoSendingResult(
+                      op, op.getOpArgs()[0], fArg, op.getOpArgs()[1], rep,
+                      dynamicRegionIsolation);
+                }
+              }
+            }
+          }
+        }
+      }
+
       p.merge(op.getOpArgs()[0], op.getOpArgs()[1]);
       return;
+    }
     case PartitionOpKind::Require:
       assert(op.getOpArgs().size() == 1 &&
              "Require PartitionOp should be passed 1 argument");
@@ -1431,10 +1496,19 @@ struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
       const PartitionOp &op, Element elt,
       SILDynamicMergedIsolationInfo regionInfo) const {}
 
+  /// Please see documentation on the CRTP version of this call for information
+  /// about this entrypoint.
   void handleTransferNonTransferrable(
       const PartitionOp &op, Element elt, Element otherElement,
       SILDynamicMergedIsolationInfo isolationRegionInfo) const {}
 
+  /// Please see documentation on the CRTP version of this call for information
+  /// about this entrypoint.
+  void handleAssignTransferNonTransferrableIntoSendingResult(
+      const PartitionOp &partitionOp, Element destElement,
+      SILFunctionArgument *destValue, Element srcElement, SILValue srcValue,
+      SILDynamicMergedIsolationInfo srcIsolationRegionInfo) const {}
+
   /// Used to signify an "unknown code pattern" has occured while performing
   /// dataflow.
   ///

include/swift/SILOptimizer/Utils/VariableNameUtils.h

@@ -201,6 +201,13 @@ class VariableNameInferrer {
   static std::optional<std::pair<Identifier, SILValue>>
   inferNameAndRoot(SILValue value);
 
+  /// Given a specific decl \p d, come up with a name for it.
+  ///
+  /// This is used internally for translating all decls to names. This is
+  /// exposed in case someone wants to wrap VariableNameUtils and needs to use
+  /// the same internal mapping that VariableNameUtils uses.
+  static StringRef getNameFromDecl(Decl *d);
+
 private:
   void drainVariableNamePath();
   void popSingleVariableName();