[region-isolation] Track if a non-Sendable value was derived from an actor and treat its region as being within an actor's isolation domain.

Importantly, we determine at the error stage if a specific value that is
transferred is within the same region of a value that is Actor derived. This
means that we can in a flow insensitive manner determine the values that are
actor derived and then via propagating those values into various regions
determine the issue... using our region analysis to handle the flow sensitivity.

One important case to reason about here is that since we are relying on the
region propagation for flow sensitivity is that this solves the var case for
us. A var when declared is never marked as actor derived. Var uses only become
actor derived if the var was merged into a region that contain is actor
derived. That means that re-assigning to a non-actor derived value, eliminates
the actor derived bit.

As part of this, I also discovered I could just get rid of the captured uniquely
identified array in favor of just passing in an actor derived flag.

rdar://115656589

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -408,7 +408,9 @@ class Partition {
           [](const PartitionOp &, Element) {},
       ArrayRef<Element> nonconsumables = {},
       llvm::function_ref<void(const PartitionOp &, Element)>
-          handleConsumeNonConsumable = [](const PartitionOp &, Element) {}) {
+          handleConsumeNonConsumable = [](const PartitionOp &, Element) {},
+      llvm::function_ref<bool(Element)> isActorDerived = nullptr) {
+
     REGIONBASEDISOLATION_VERBOSE_LOG(llvm::dbgs() << "Applying: ";
                                      op.print(llvm::dbgs()));
     REGIONBASEDISOLATION_VERBOSE_LOG(llvm::dbgs() << "    Before: ";
@@ -444,7 +446,7 @@ class Partition {
       fresh_label = Region(fresh_label + 1);
       canonical = false;
       break;
-    case PartitionOpKind::Transfer:
+    case PartitionOpKind::Transfer: {
       assert(op.OpArgs.size() == 1 &&
              "Consume PartitionOp should be passed 1 argument");
       assert(labels.count(op.OpArgs[0]) &&
@@ -464,12 +466,26 @@ class Partition {
         }
       }
 
-      // ensure region is transferred
+      // If this value is actor derived or if any elements in its region are
+      // actor derived, we need to treat as non-consumable.
+      if (isActorDerived && isActorDerived(op.OpArgs[0]))
+        return handleConsumeNonConsumable(op, op.OpArgs[0]);
+      Region elementRegion = labels.at(op.OpArgs[0]);
+      if (llvm::any_of(labels,
+                       [&](const std::pair<Element, Region> &pair) -> bool {
+                         if (pair.second != elementRegion)
+                           return false;
+                         return isActorDerived && isActorDerived(pair.first);
+                       }))
+        return handleConsumeNonConsumable(op, op.OpArgs[0]);
+
+      // Ensure if the region is transferred...
       if (!isTransferred(op.OpArgs[0]))
-        // mark region as transferred
+        // that all elements associated with the region are marked as
+        // transferred.
         horizontalUpdate(labels, op.OpArgs[0], Region::transferred());
-
       break;
+    }
     case PartitionOpKind::Merge:
       assert(op.OpArgs.size() == 2 &&
              "Merge PartitionOp should be passed 2 arguments");