[ownership] Make destructure_{struct,tuple} true forwarding instructions instead of inferring from results/arguments.

Author: gottesmm

include/swift/SIL/SILInstruction.h

@@ -8753,6 +8753,23 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
   }
 }
 
+class OwnershipForwardingMultipleValueInstruction
+    : public MultipleValueInstruction {
+  ValueOwnershipKind ownershipKind;
+
+public:
+  OwnershipForwardingMultipleValueInstruction(SILInstructionKind kind,
+                                              SILDebugLocation loc,
+                                              ValueOwnershipKind ownershipKind)
+      : MultipleValueInstruction(kind, loc), ownershipKind(ownershipKind) {}
+
+  /// Returns the preferred ownership kind of this multiple value instruction.
+  ValueOwnershipKind getOwnershipKind() const { return ownershipKind; }
+  void setOwnershipKind(ValueOwnershipKind newOwnershipKind) {
+    ownershipKind = newOwnershipKind;
+  }
+};
+
 /// A result for the destructure_struct instruction. See documentation for
 /// destructure_struct for more information.
 class DestructureStructResult final : public MultipleValueInstructionResult {
@@ -8776,15 +8793,15 @@ class DestructureStructResult final : public MultipleValueInstructionResult {
 /// struct's fields.
 class DestructureStructInst final
     : public UnaryInstructionBase<SILInstructionKind::DestructureStructInst,
-                                  MultipleValueInstruction>,
-      public MultipleValueInstructionTrailingObjects<
-          DestructureStructInst, DestructureStructResult> {
+                                  OwnershipForwardingMultipleValueInstruction>,
+      public MultipleValueInstructionTrailingObjects<DestructureStructInst,
+                                                     DestructureStructResult> {
   friend TrailingObjects;
 
   DestructureStructInst(SILModule &M, SILDebugLocation Loc, SILValue Operand,
                         ArrayRef<SILType> Types,
                         ArrayRef<ValueOwnershipKind> OwnershipKinds)
-      : UnaryInstructionBase(Loc, Operand),
+      : UnaryInstructionBase(Loc, Operand, Operand.getOwnershipKind()),
         MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
 
 public:
@@ -8825,15 +8842,15 @@ class DestructureTupleResult final : public MultipleValueInstructionResult {
 /// tuples's elements.
 class DestructureTupleInst final
     : public UnaryInstructionBase<SILInstructionKind::DestructureTupleInst,
-                                  MultipleValueInstruction>,
-      public MultipleValueInstructionTrailingObjects<
-          DestructureTupleInst, DestructureTupleResult> {
+                                  OwnershipForwardingMultipleValueInstruction>,
+      public MultipleValueInstructionTrailingObjects<DestructureTupleInst,
+                                                     DestructureTupleResult> {
   friend TrailingObjects;
 
   DestructureTupleInst(SILModule &M, SILDebugLocation Loc, SILValue Operand,
                        ArrayRef<SILType> Types,
                        ArrayRef<ValueOwnershipKind> OwnershipKinds)
-      : UnaryInstructionBase(Loc, Operand),
+      : UnaryInstructionBase(Loc, Operand, Operand.getOwnershipKind()),
         MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
 
 public:

lib/SIL/IR/OperandOwnership.cpp

@@ -344,14 +344,29 @@ FORWARD_ANY_OWNERSHIP_INST(RefToBridgeObject)
 FORWARD_ANY_OWNERSHIP_INST(BridgeObjectToRef)
 FORWARD_ANY_OWNERSHIP_INST(UnconditionalCheckedCast)
 FORWARD_ANY_OWNERSHIP_INST(UncheckedEnumData)
-FORWARD_ANY_OWNERSHIP_INST(DestructureStruct)
-FORWARD_ANY_OWNERSHIP_INST(DestructureTuple)
 FORWARD_ANY_OWNERSHIP_INST(InitExistentialRef)
 FORWARD_ANY_OWNERSHIP_INST(DifferentiableFunction)
 FORWARD_ANY_OWNERSHIP_INST(LinearFunction)
 FORWARD_ANY_OWNERSHIP_INST(UncheckedValueCast)
 #undef FORWARD_ANY_OWNERSHIP_INST
 
+// Temporary implementation for staging purposes.
+OperandOwnershipKindMap
+OperandOwnershipKindClassifier::visitDestructureStructInst(
+    DestructureStructInst *dsi) {
+  auto kind = dsi->getOwnershipKind();
+  auto constraint = kind.getForwardingLifetimeConstraint();
+  return {kind, constraint};
+}
+
+OperandOwnershipKindMap
+OperandOwnershipKindClassifier::visitDestructureTupleInst(
+    DestructureTupleInst *dsi) {
+  auto kind = dsi->getOwnershipKind();
+  auto constraint = kind.getForwardingLifetimeConstraint();
+  return {kind, constraint};
+}
+
 // An instruction that forwards a constant ownership or trivial ownership.
 #define FORWARD_CONSTANT_OR_NONE_OWNERSHIP_INST(OWNERSHIP,                     \
                                                 USE_LIFETIME_CONSTRAINT, INST) \

lib/SIL/Verifier/SILVerifier.cpp

@@ -2915,6 +2915,41 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     require(!sd->isResilient(F.getModule().getSwiftModule(),
                              F.getResilienceExpansion()),
             "cannot access storage of resilient struct");
+    if (F.hasOwnership()) {
+      // Make sure that all of our destructure results ownership kinds are
+      // compatible with our destructure_struct's ownership kind /and/ that if
+      // our destructure ownership kind is non-trivial then all non-trivial
+      // results must have the same ownership kind as our operand.
+      auto parentKind = DSI->getOwnershipKind();
+      for (const DestructureStructResult &result : DSI->getAllResultsBuffer()) {
+        require(parentKind.isCompatibleWith(result.getOwnershipKind()),
+                "destructure result with ownership that is incompatible with "
+                "parent forwarding ownership kind");
+        require(parentKind != ValueOwnershipKind::None ||
+                    result.getOwnershipKind() == ValueOwnershipKind::None,
+                "destructure with none ownership kind operand and non-none "
+                "ownership kind result?!");
+      }
+    }
+  }
+
+  void checkDestructureTupleInst(DestructureTupleInst *dti) {
+    if (F.hasOwnership()) {
+      // Make sure that all of our destructure results ownership kinds are
+      // compatible with our destructure_struct's ownership kind /and/ that if
+      // our destructure ownership kind is non-trivial then all non-trivial
+      // results must have the same ownership kind as our operand.
+      auto parentKind = dti->getOwnershipKind();
+      for (const auto &result : dti->getAllResultsBuffer()) {
+        require(parentKind.isCompatibleWith(result.getOwnershipKind()),
+                "destructure result with ownership that is incompatible with "
+                "parent forwarding ownership kind");
+        require(parentKind != ValueOwnershipKind::None ||
+                    result.getOwnershipKind() == ValueOwnershipKind::None,
+                "destructure with none ownership kind operand and non-none "
+                "ownership kind result?!");
+      }
+    }
   }
 
   SILType getMethodSelfType(CanSILFunctionType ft) {