[region-isolation] Make it possible to "lookThrough" multiple result instructions and use it to lookthrough destructures.

Currently when one says that an instruction is not a "look through" instruction,
each of its results gets a separate element number and we track these results as
independent entities that can be in a region. The one issue with this is
whenever we perform this sort of operation we actually are at the same time
performing a require on the operand of the instruction. This causes us to emit
errors on non-side effect having instructions when we really want to emit an
error on their side-effect having results. As an example of the world before
this patch, the following example would force the struct_element_addr to have a
require so we would emit an error on it instead of the apply (the thing that we
actually care about):

```
%0 = ...

// We transferred %0, so we cannot use it again.
apply %transfer(%0)

// We track %1 and %0 as separate elements and we treat this as an assignment of
// %0 into %1 which forces %0 to be required live at this point causing us to
// emit an error here...
%1 = struct_element_addr %0

// Instead of in the SIL here on the actual side-effect having instruction.
apply %actualUse(%1)
```

the solution is to make instructions like struct_element_addr lookthrough
instructions which force their result to just be the same element as their
operand. As part of doing this, we have to ensure that getUnderlyingTrackedValue
knows how to look through these types. This ensures that they are not considered
roots.

----

As an aside to implement this I needed to compose some functionality ontop of
getUnderlyingObject (specifically the look through behavior on destructures) in
a new helper routine called getUnderlyingTrackedObjectValue(). It just in a loop
calls getUnderlyingObject() and looks through destructures until its iterator
doesn't change.

Author: gottesmm

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -140,9 +140,34 @@ struct UseDefChainVisitor
 
 } // namespace
 
+static SILValue getUnderlyingTrackedObjectValue(SILValue value) {
+  SILValue result = value;
+  while (true) {
+    SILValue temp = result;
+
+    temp = getUnderlyingObject(temp);
+
+    if (auto *dsi = dyn_cast_or_null<DestructureStructInst>(
+            temp->getDefiningInstruction())) {
+      temp = dsi->getOperand();
+    }
+    if (auto *dti = dyn_cast_or_null<DestructureTupleInst>(
+            temp->getDefiningInstruction())) {
+      temp = dti->getOperand();
+    }
+
+    if (temp != result) {
+      result = temp;
+      continue;
+    }
+
+    return result;
+  }
+}
+
 static SILValue getUnderlyingTrackedValue(SILValue value) {
   if (!value->getType().isAddress()) {
-    return getUnderlyingObject(value);
+    return getUnderlyingTrackedObjectValue(value);
   }
 
   UseDefChainVisitor visitor;
@@ -837,6 +862,17 @@ class PartitionOpTranslator {
         builder.addAssignFresh(value->getRepresentative());
   }
 
+  template <typename DestValues>
+  void translateSILLookThrough(DestValues destValues, SILValue src) {
+    auto srcID = tryToTrackValue(src);
+
+    for (SILValue dest : destValues) {
+      auto destID = tryToTrackValue(dest);
+      assert(((!destID || !srcID) || destID->getID() == srcID->getID()) &&
+             "srcID and dstID are different?!");
+    }
+  }
+
   /// Add a look through operation. This asserts that dest and src map to the
   /// same ID. Should only be used on instructions that are always guaranteed to
   /// have this property due to getUnderlyingTrackedValue looking through them.
@@ -846,7 +882,8 @@ class PartitionOpTranslator {
   /// explicit. Previously, we always called translateSILAssign and relied on
   /// the builder to recognize these cases and not create an assign
   /// PartitionOp. Doing such a thing obscures what is actually happening.
-  void translateSILLookThrough(SILValue dest, SILValue src) {
+  template <>
+  void translateSILLookThrough<SILValue>(SILValue dest, SILValue src) {
     auto srcID = tryToTrackValue(src);
     auto destID = tryToTrackValue(dest);
     assert(((!destID || !srcID) || destID->getID() == srcID->getID()) &&
@@ -1059,6 +1096,11 @@ class PartitionOpTranslator {
     case SILInstructionKind::UpcastInst:
       return translateSILLookThrough(inst->getResult(0), inst->getOperand(0));
 
+    // We identify tuple results with their operand's id.
+    case SILInstructionKind::DestructureTupleInst:
+    case SILInstructionKind::DestructureStructInst:
+      return translateSILLookThrough(inst->getResults(), inst->getOperand(0));
+
     case SILInstructionKind::UnconditionalCheckedCastInst:
       if (SILDynamicCastInst(inst).isRCIdentityPreserving())
         return translateSILLookThrough(inst->getResult(0), inst->getOperand(0));
@@ -1133,14 +1175,6 @@ class PartitionOpTranslator {
     case SILInstructionKind::TryApplyInst:
       return translateSILApply(inst);
 
-    // These are used by SIL to disaggregate values together in a gep like
-    // way. We want to error on uses, not on the destructure itself, so we
-    // propagate.
-    case SILInstructionKind::DestructureTupleInst:
-    case SILInstructionKind::DestructureStructInst:
-      return translateSILMultiAssign(inst->getResults(),
-                                     inst->getOperandValues());
-
     // These are used by SIL to aggregate values together in a gep like way. We
     // want to look at uses of structs, not the struct uses itself. So just
     // propagate.