[region-isolation] When assigning RValues into memory, use tuple_addr_constructor instead of doing it in pieces.

I also included changes to the rest of the SIL optimizer pipeline to ensure that
the part of the optimizer pipeline before we lower tuple_addr_constructor (which
is right after we run TransferNonSendable) work as before.

The reason why I am doing this is that this ensures that diagnostic passes can
tell the difference in between:

```
x = (a, b, c)
```

and

```
x.0 = a
x.1 = b
x.2 = c
```

This is important for things like TransferNonSendable where assigning over the
entire tuple element is treated differently from if one were to initialize it in
pieces using projections.

rdar://117880194

Author: gottesmm

include/swift/SIL/SILCloner.h

@@ -2184,11 +2184,29 @@ SILCloner<ImplClass>::visitTupleInst(TupleInst *Inst) {
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitTupleAddrConstructorInst(
     TupleAddrConstructorInst *Inst) {
-  auto Elements = getOpValueArray<8>(Inst->getElements());
+  SmallVector<SILValue, 8> Elements;
+  for (auto e : Inst->getElements()) {
+    SILValue mappedValue = getOpValue(e);
+
+    // Check if mappedValue only consists of empty tuple elements. If it does,
+    // then we do not add it to our result. This is because we know that the
+    // corresponding elements in getOpValue(Inst->getDest()) will also change
+    // into an empty exploded tuple. Since we only have leaf non-empty non-tuple
+    // elements as operands, these are not represented.
+    bool FoundNonTuple = false;
+    mappedValue->getType().getASTType().visit(
+        [&](CanType ty) { FoundNonTuple |= !ty->is<TupleType>(); });
+    if (FoundNonTuple)
+      Elements.push_back(mappedValue);
+  }
+
+  if (Elements.empty())
+    return;
+
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(Inst, getBuilder().createTupleAddrConstructor(
                                     getOpLocation(Inst->getLoc()),
-                                    getOpValue(Inst->getDestValue()), Elements,
+                                    getOpValue(Inst->getDest()), Elements,
                                     Inst->isInitializationOfDest()));
 }
 

include/swift/SIL/SILInstruction.h

@@ -6372,10 +6372,10 @@ class TupleAddrConstructorInst final
     Dest = 0,
   };
 
-  Operand &getDest() { return getAllOperands().front(); }
-  const Operand &getDest() const { return getAllOperands().front(); }
+  Operand &getDestOperand() { return getAllOperands().front(); }
+  const Operand &getDestOperand() const { return getAllOperands().front(); }
 
-  SILValue getDestValue() const { return getDest().get(); }
+  SILValue getDest() const { return getDestOperand().get(); }
 
   /// The elements referenced by this TupleInst.
   MutableArrayRef<Operand> getElementOperands() {
@@ -6392,14 +6392,16 @@ class TupleAddrConstructorInst final
 
   unsigned getElementIndex(Operand *operand) {
     assert(operand->getUser() == this);
-    assert(operand != &getDest() && "Cannot pass in the destination");
+    assert(operand != &getDestOperand() && "Cannot pass in the destination");
     return operand->getOperandNumber() + 1;
   }
 
   unsigned getNumElements() const { return getTupleType()->getNumElements(); }
 
   TupleType *getTupleType() const {
-    return getDest().get()->getType().getRawASTType()->castTo<TupleType>();
+    // We use getASTType() since we want to look through a wrapped noncopyable
+    // type to get to the underlying tuple type.
+    return getDest()->getType().getASTType()->castTo<TupleType>();
   }
 
   IsInitialization_t isInitializationOfDest() const {

lib/SIL/IR/SILPrinter.cpp

@@ -2223,7 +2223,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     } else {
       *this << "[assign] ";
     }
-    *this << getIDAndType(TI->getDestValue());
+    *this << getIDAndType(TI->getDest());
 
     *this << " with (";
 

lib/SIL/Utils/InstructionUtils.cpp

@@ -750,7 +750,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
   }
   case SILInstructionKind::TupleAddrConstructorInst: {
     auto *ca = cast<TupleAddrConstructorInst>(inst);
-    impactType = ca->getDestValue()->getType();
+    impactType = ca->getDest()->getType();
     if (!ca->isInitializationOfDest())
       return RuntimeEffect::MetaData | RuntimeEffect::Releasing;
     return RuntimeEffect::MetaData;

lib/SIL/Verifier/MemoryLifetimeVerifier.cpp

@@ -417,7 +417,7 @@ void MemoryLifetimeVerifier::initDataflowInBlock(SILBasicBlock *block,
           if (elt->getType().isAddress())
             killBits(state, elt);
         }
-        genBits(state, taci->getDestValue());
+        genBits(state, taci->getDest());
         break;
       }
       case SILInstructionKind::DestroyAddrInst:

lib/SIL/Verifier/SILVerifier.cpp

@@ -3290,6 +3290,22 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
   }
 
+  void checkTupleAddrConstructorInst(TupleAddrConstructorInst *taci) {
+    require(taci->getNumElements() > 0,
+            "Cannot be applied to tuples that do not contain any real "
+            "elements. E.x.: ((), ())");
+    for (auto elt : taci->getElements()) {
+      // We cannot have any elements that contain only tuple elements. This is
+      // due to our exploded representation. This means when specializing,
+      // cloners must eliminate these parameters.
+      bool hasNonTuple = false;
+      elt->getType().getASTType().visit([&](CanType ty) {
+        hasNonTuple |= !ty->is<TupleType>();
+      });
+      require(hasNonTuple, "Element only consists of tuples");
+    }
+  }
+
   // Is a SIL type a potential lowering of a formal type?
   bool isLoweringOf(SILType loweredType, CanType formalType) {
     return loweredType.isLoweringOf(F.getTypeExpansionContext(), F.getModule(),

lib/SILGen/RValue.cpp

@@ -558,36 +558,33 @@ void RValue::copyInto(SILGenFunction &SGF, SILLocation loc,
   copyOrInitValuesInto<ImplodeKind::Copy>(I, elts, type, loc, SGF);
 }
 
-static void assignRecursive(SILGenFunction &SGF, SILLocation loc,
-                            CanType type, ArrayRef<ManagedValue> &srcValues,
-                            SILValue destAddr) {
-  // Recurse into tuples.
+void RValue::assignInto(SILGenFunction &SGF, SILLocation loc,
+                        SILValue destAddr) && {
+  assert(isComplete() && "rvalue is not complete");
+  assert(isPlusOneOrTrivial(SGF) && "Can not assign borrowed RValues");
+  ArrayRef<ManagedValue> srcMvValues = values;
+
+  SWIFT_DEFER { assert(srcMvValues.empty() && "didn't claim all elements!"); };
+
+  // If we do not have a tuple, just bail early.
   auto srcTupleType = dyn_cast<TupleType>(type);
-  if (srcTupleType && !srcTupleType.containsPackExpansionType()) {
-    assert(destAddr->getType().castTo<TupleType>()->getNumElements()
-             == srcTupleType->getNumElements());
-    for (auto eltIndex : indices(srcTupleType.getElementTypes())) {
-      auto eltDestAddr = SGF.B.createTupleElementAddr(loc, destAddr, eltIndex);
-      assignRecursive(SGF, loc, srcTupleType.getElementType(eltIndex),
-                      srcValues, eltDestAddr);
-    }
+  if (!srcTupleType || srcTupleType.containsPackExpansionType()) {
+    // Otherwise, pull the front value off the list.
+    auto srcValue = srcMvValues.front();
+    srcMvValues = srcMvValues.slice(1);
+    srcValue.assignInto(SGF, loc, destAddr);
     return;
   }
 
-  // Otherwise, pull the front value off the list.
-  auto srcValue = srcValues.front();
-  srcValues = srcValues.slice(1);
+  assert(destAddr->getType().castTo<TupleType>()->getNumElements() ==
+         srcTupleType->getNumElements());
 
-  srcValue.assignInto(SGF, loc, destAddr);
-}
-
-void RValue::assignInto(SILGenFunction &SGF, SILLocation loc,
-                        SILValue destAddr) && {
-  assert(isComplete() && "rvalue is not complete");
-  assert(isPlusOneOrTrivial(SGF) && "Can not assign borrowed RValues");
-  ArrayRef<ManagedValue> srcValues = values;
-  assignRecursive(SGF, loc, type, srcValues, destAddr);
-  assert(srcValues.empty() && "didn't claim all elements!");
+  // If we do have any srcMvValues, then emit a TupleAddrConstructor. If we do
+  // not have any, then our tuple must consist only of empty tuples.
+  if (srcMvValues.size())
+    SGF.B.createTupleAddrConstructor(loc, destAddr, srcMvValues,
+                                     IsNotInitialization);
+  srcMvValues = ArrayRef<ManagedValue>();
 }
 
 ManagedValue RValue::getAsSingleValue(SILGenFunction &SGF, SILLocation loc) && {

lib/SILGen/SILGenBuilder.h

@@ -505,6 +505,19 @@ class SILGenBuilder : public SILBuilder {
   void createEndLifetime(SILLocation loc, ManagedValue selfValue) {
     createEndLifetime(loc, selfValue.forward(SGF));
   }
+
+  using SILBuilder::createTupleAddrConstructor;
+
+  void createTupleAddrConstructor(SILLocation loc, SILValue destAddr,
+                                  ArrayRef<ManagedValue> elements,
+                                  IsInitialization_t isInitOfDest) {
+    SmallVector<SILValue, 8> values;
+    for (auto mv : elements) {
+      values.push_back(mv.forward(SGF));
+    }
+
+    createTupleAddrConstructor(loc, destAddr, values, isInitOfDest);
+  }
 };
 
 } // namespace Lowering

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -908,6 +908,27 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
       continue;
     }
 
+    if (auto *TACI = dyn_cast<TupleAddrConstructorInst>(User)) {
+      // If this is the source of the copy_addr, then this is a load.  If it is
+      // the destination, then this is an unknown assignment.  Note that we'll
+      // revisit this instruction and add it to Uses twice if it is both a load
+      // and store to the same aggregate.
+      DIUseKind Kind;
+      if (TACI->getDest() == Op->get()) {
+        if (InStructSubElement)
+          Kind = DIUseKind::PartialStore;
+        else if (TACI->isInitializationOfDest())
+          Kind = DIUseKind::Initialization;
+        else
+          Kind = DIUseKind::InitOrAssign;
+      } else {
+        Kind = DIUseKind::Load;
+      }
+
+      addElementUses(BaseEltNo, PointeeType, User, Kind);
+      continue;
+    }
+
     if (auto *MAI = dyn_cast<MarkUnresolvedMoveAddrInst>(User)) {
       // If this is the source of the copy_addr, then this is a load.  If it is
       // the destination, then this is an unknown assignment.  Note that we'll

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2529,6 +2529,30 @@ void LifetimeChecker::updateInstructionForInitState(unsigned UseID) {
     return;
   }
 
+  if (auto *TACI = dyn_cast<TupleAddrConstructorInst>(Inst)) {
+    assert(!TACI->isInitializationOfDest() &&
+           "should not modify copy_addr that already knows it is initialized");
+    TACI->setIsInitializationOfDest(InitKind);
+    if (InitKind == IsInitialization)
+      setStaticInitAccess(TACI->getDest());
+
+    // If we had an initialization and had an assignable_but_not_consumable
+    // noncopyable type, convert it to be an initable_but_not_consumable so that
+    // we do not consume an uninitialized value.
+    if (InitKind == IsInitialization) {
+      if (auto *mmci = dyn_cast<MarkUnresolvedNonCopyableValueInst>(
+              stripAccessMarkers(TACI->getDest()))) {
+        if (mmci->getCheckKind() == MarkUnresolvedNonCopyableValueInst::
+                                        CheckKind::AssignableButNotConsumable) {
+          mmci->setCheckKind(MarkUnresolvedNonCopyableValueInst::CheckKind::
+                                 InitableButNotConsumable);
+        }
+      }
+    }
+
+    return;
+  }
+
   // Ignore non-stores for SelfInits.
   assert(isa<StoreInst>(Inst) && "Unknown store instruction!");
 }