Rename OwnershipForwardingMixin -> ForwardingInstruction

Author: meg-gupta

include/swift/SIL/OwnershipUseVisitor.h

@@ -296,7 +296,7 @@ bool OwnershipUseVisitor<Impl>::visitInnerBorrowScopeEnd(Operand *borrowEnd) {
     // TODO: When we have ForwardingInstruction abstraction, walk the use-def
     // chain to ensure we have a partial_apply [on_stack] def.
     assert(pai && pai->isOnStack() ||
-           OwnershipForwardingMixin::get(
+           ForwardingInstruction::get(
                cast<SingleValueInstruction>(borrowEnd->get())));
     return handleUsePoint(borrowEnd, UseLifetimeConstraint::NonLifetimeEnding);
   }

include/swift/SIL/OwnershipUtils.h

@@ -219,7 +219,7 @@ class ForwardingOperand {
   }
 
   bool preservesOwnership() const {
-    auto &mixin = *OwnershipForwardingMixin::get(use->getUser());
+    auto &mixin = *ForwardingInstruction::get(use->getUser());
     return mixin.preservesOwnership();
   }
 

include/swift/SIL/SILInstruction.h

@@ -1191,14 +1191,14 @@ class CopyLikeInstruction {
 ///
 /// NOTE: We assume that the constructor for the instruction subclass that
 /// initializes the kind field on our object is run before our constructor runs.
-class OwnershipForwardingMixin {
+class ForwardingInstruction {
   ValueOwnershipKind ownershipKind;
   bool preservesOwnershipFlag;
 
 protected:
-  OwnershipForwardingMixin(SILInstructionKind kind,
-                           ValueOwnershipKind ownershipKind,
-                           bool preservesOwnership = true)
+  ForwardingInstruction(SILInstructionKind kind,
+                        ValueOwnershipKind ownershipKind,
+                        bool preservesOwnership = true)
       : ownershipKind(ownershipKind),
         preservesOwnershipFlag(preservesOwnership) {
     assert(isa(kind) && "Invalid subclass?!");
@@ -1240,7 +1240,7 @@ class OwnershipForwardingMixin {
   }
 
   /// Defined inline below due to forward declaration issues.
-  static OwnershipForwardingMixin *get(SILInstruction *inst);
+  static ForwardingInstruction *get(SILInstruction *inst);
   /// Defined inline below due to forward declaration issues.
   static bool isa(SILInstructionKind kind);
   static bool isa(const SILInstruction *inst) { return isa(inst->getKind()); }
@@ -1253,13 +1253,13 @@ class OwnershipForwardingMixin {
   /// Return true if the forwarded value has the same representation. If true,
   /// then the result can be mapped to the same storage without a move or copy.
   ///
-  /// \p inst is an OwnershipForwardingMixin
+  /// \p inst is an ForwardingInstruction
   static bool hasSameRepresentation(SILInstruction *inst);
 
   /// Return true if the forwarded value is address-only either before or after
   /// forwarding.
   ///
-  /// \p inst is an OwnershipForwardingMixin
+  /// \p inst is an ForwardingInstruction
   static bool isAddressOnly(SILInstruction *inst);
 };
 
@@ -1272,14 +1272,14 @@ class OwnershipForwardingMixin {
 /// operation that has no operand at all, like `enum .None`.
 class FirstArgOwnershipForwardingSingleValueInst
     : public SingleValueInstruction,
-      public OwnershipForwardingMixin {
+      public ForwardingInstruction {
 protected:
   FirstArgOwnershipForwardingSingleValueInst(SILInstructionKind kind,
                                              SILDebugLocation debugLoc,
                                              SILType ty,
                                              ValueOwnershipKind ownershipKind)
       : SingleValueInstruction(kind, debugLoc, ty),
-        OwnershipForwardingMixin(kind, ownershipKind) {
+        ForwardingInstruction(kind, ownershipKind) {
     assert(classof(kind) && "classof missing new subclass?!");
   }
 
@@ -1404,16 +1404,15 @@ FirstArgOwnershipForwardingSingleValueInst::classof(SILInstructionKind kind) {
   }
 }
 
-class AllArgOwnershipForwardingSingleValueInst
-    : public SingleValueInstruction,
-      public OwnershipForwardingMixin {
+class AllArgOwnershipForwardingSingleValueInst : public SingleValueInstruction,
+                                                 public ForwardingInstruction {
 protected:
   AllArgOwnershipForwardingSingleValueInst(SILInstructionKind kind,
                                            SILDebugLocation debugLoc,
                                            SILType ty,
                                            ValueOwnershipKind ownershipKind)
       : SingleValueInstruction(kind, debugLoc, ty),
-        OwnershipForwardingMixin(kind, ownershipKind) {
+        ForwardingInstruction(kind, ownershipKind) {
     assert(classof(kind) && "classof missing new subclass?!");
   }
 
@@ -5549,13 +5548,13 @@ class ConversionInst : public SingleValueInstruction {
 ///
 /// The first operand is the ownership equivalent source.
 class OwnershipForwardingConversionInst : public ConversionInst,
-                                          public OwnershipForwardingMixin {
+                                          public ForwardingInstruction {
 protected:
   OwnershipForwardingConversionInst(SILInstructionKind kind,
                                     SILDebugLocation debugLoc, SILType ty,
                                     ValueOwnershipKind ownershipKind)
       : ConversionInst(kind, debugLoc, ty),
-        OwnershipForwardingMixin(kind, ownershipKind) {
+        ForwardingInstruction(kind, ownershipKind) {
     assert(classof(kind) && "classof missing subclass?!");
   }
 
@@ -6784,15 +6783,15 @@ class SelectEnumInstBase
 
 /// A select enum inst that produces a static OwnershipKind.
 class OwnershipForwardingSelectEnumInstBase : public SelectEnumInstBase,
-                                              public OwnershipForwardingMixin {
+                                              public ForwardingInstruction {
 protected:
   OwnershipForwardingSelectEnumInstBase(
       SILInstructionKind kind, SILDebugLocation debugLoc, SILType type,
       bool defaultValue, Optional<ArrayRef<ProfileCounter>> caseCounts,
       ProfileCounter defaultCount, ValueOwnershipKind ownershipKind)
       : SelectEnumInstBase(kind, debugLoc, type, defaultValue, caseCounts,
                            defaultCount),
-        OwnershipForwardingMixin(kind, ownershipKind) {
+        ForwardingInstruction(kind, ownershipKind) {
     assert(classof(kind) && "classof missing subclass");
   }
 
@@ -8413,7 +8412,7 @@ class MarkUnresolvedMoveAddrInst
 class MarkMustCheckInst
     : public UnaryInstructionBase<SILInstructionKind::MarkMustCheckInst,
                                   SingleValueInstruction>,
-      public OwnershipForwardingMixin {
+      public ForwardingInstruction {
   friend class SILBuilder;
 
 public:
@@ -8453,8 +8452,8 @@ class MarkMustCheckInst
   MarkMustCheckInst(SILDebugLocation DebugLoc, SILValue operand,
                     CheckKind checkKind)
       : UnaryInstructionBase(DebugLoc, operand, operand->getType()),
-        OwnershipForwardingMixin(SILInstructionKind::MarkMustCheckInst,
-                                 operand->getOwnershipKind()),
+        ForwardingInstruction(SILInstructionKind::MarkMustCheckInst,
+                              operand->getOwnershipKind()),
         kind(checkKind) {
     assert(operand->getType().isMoveOnly() &&
            "mark_must_check can only take a move only typed value");
@@ -8484,7 +8483,7 @@ class MarkUnresolvedReferenceBindingInst
     : public UnaryInstructionBase<
           SILInstructionKind::MarkUnresolvedReferenceBindingInst,
           SingleValueInstruction>,
-      public OwnershipForwardingMixin {
+      public ForwardingInstruction {
   friend class SILBuilder;
 
 public:
@@ -8500,7 +8499,7 @@ class MarkUnresolvedReferenceBindingInst
   MarkUnresolvedReferenceBindingInst(SILDebugLocation debugLoc,
                                      SILValue operand, Kind kind)
       : UnaryInstructionBase(debugLoc, operand, operand->getType()),
-        OwnershipForwardingMixin(
+        ForwardingInstruction(
             SILInstructionKind::MarkUnresolvedReferenceBindingInst,
             operand->getOwnershipKind()),
         kind(kind) {}
@@ -9271,14 +9270,14 @@ class TermInst : public NonValueInstruction {
 
 // Forwards the first operand to a result in each successor block.
 class OwnershipForwardingTermInst : public TermInst,
-                                    public OwnershipForwardingMixin {
+                                    public ForwardingInstruction {
 protected:
   OwnershipForwardingTermInst(SILInstructionKind kind,
                               SILDebugLocation debugLoc,
                               ValueOwnershipKind ownershipKind,
                               bool preservesOwnership = true)
       : TermInst(kind, debugLoc),
-        OwnershipForwardingMixin(kind, ownershipKind, preservesOwnership) {
+        ForwardingInstruction(kind, ownershipKind, preservesOwnership) {
     assert(classof(kind));
   }
 
@@ -10791,13 +10790,13 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
 /// The first operand is the ownership equivalent source.
 class OwnershipForwardingMultipleValueInstruction
     : public MultipleValueInstruction,
-      public OwnershipForwardingMixin {
+      public ForwardingInstruction {
 public:
   OwnershipForwardingMultipleValueInstruction(SILInstructionKind kind,
                                               SILDebugLocation loc,
                                               ValueOwnershipKind ownershipKind)
       : MultipleValueInstruction(kind, loc),
-        OwnershipForwardingMixin(kind, ownershipKind) {
+        ForwardingInstruction(kind, ownershipKind) {
     assert(classof(kind) && "Missing subclass from classof?!");
   }
 
@@ -10941,7 +10940,7 @@ inline bool Operand::isTypeDependent() const {
   return getUser()->isTypeDependentOperand(*this);
 }
 
-inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
+inline bool ForwardingInstruction::isa(SILInstructionKind kind) {
   return FirstArgOwnershipForwardingSingleValueInst::classof(kind) ||
          AllArgOwnershipForwardingSingleValueInst::classof(kind) ||
          OwnershipForwardingTermInst::classof(kind) ||
@@ -10952,12 +10951,11 @@ inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
          kind == SILInstructionKind::MarkUnresolvedReferenceBindingInst;
 }
 
-inline OwnershipForwardingMixin *
-OwnershipForwardingMixin::get(SILInstruction *inst) {
+inline ForwardingInstruction *ForwardingInstruction::get(SILInstruction *inst) {
   // I am purposely performing this cast in this manner rather than reinterpret
-  // casting to OwnershipForwardingMixin to ensure that we offset to the
+  // casting to ForwardingInstruction to ensure that we offset to the
   // appropriate offset inside of inst instead of converting inst's current
-  // location to an OwnershipForwardingMixin which would be incorrect.
+  // location to an ForwardingInstruction which would be incorrect.
   if (auto *result = dyn_cast<FirstArgOwnershipForwardingSingleValueInst>(inst))
     return result;
   if (auto *result = dyn_cast<AllArgOwnershipForwardingSingleValueInst>(inst))

lib/SIL/IR/SILInstructions.cpp

@@ -3200,15 +3200,15 @@ ReturnInst::ReturnInst(SILFunction &func, SILDebugLocation debugLoc,
          "result info?!");
 }
 
-bool OwnershipForwardingMixin::hasSameRepresentation(SILInstruction *inst) {
+bool ForwardingInstruction::hasSameRepresentation(SILInstruction *inst) {
   switch (inst->getKind()) {
   // Explicitly list instructions which definitely involve a representation
   // change.
   case SILInstructionKind::SwitchEnumInst:
   default:
     // Conservatively assume that a conversion changes representation.
     // Operations can be added as needed to participate in SIL opaque values.
-    assert(OwnershipForwardingMixin::isa(inst));
+    assert(ForwardingInstruction::isa(inst));
     return false;
 
   case SILInstructionKind::ConvertFunctionInst:
@@ -3228,14 +3228,14 @@ bool OwnershipForwardingMixin::hasSameRepresentation(SILInstruction *inst) {
   }
 }
 
-bool OwnershipForwardingMixin::isAddressOnly(SILInstruction *inst) {
+bool ForwardingInstruction::isAddressOnly(SILInstruction *inst) {
   if (auto *aggregate =
-      dyn_cast<AllArgOwnershipForwardingSingleValueInst>(inst)) {
+          dyn_cast<AllArgOwnershipForwardingSingleValueInst>(inst)) {
     // If any of the operands are address-only, then the aggregate must be.
     return aggregate->getType().isAddressOnly(*inst->getFunction());
   }
   // All other forwarding instructions must forward their first operand.
-  assert(OwnershipForwardingMixin::isa(inst));
+  assert(ForwardingInstruction::isa(inst));
   return inst->getOperand(0)->getType().isAddressOnly(*inst->getFunction());
 }
 

lib/SIL/IR/SILPrinter.cpp

@@ -1725,8 +1725,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
   }
 
-  void printForwardingOwnershipKind(OwnershipForwardingMixin *inst,
-                                    SILValue op) {
+  void printForwardingOwnershipKind(ForwardingInstruction *inst, SILValue op) {
     if (!op)
       return;
 

lib/SIL/Parser/ParseSIL.cpp

@@ -4273,7 +4273,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       return true;
 
     ValueOwnershipKind forwardingOwnership = Val->getOwnershipKind();
-    if (OwnershipForwardingMixin::isa(Opcode)) {
+    if (ForwardingInstruction::isa(Opcode)) {
       if (parseForwardingOwnershipKind(forwardingOwnership))
         return true;
     }

lib/SIL/Utils/MemAccessUtils.cpp

@@ -899,10 +899,10 @@ SILValue swift::findOwnershipReferenceAggregate(SILValue ref) {
     if (!root)
       return root;
 
-    if (isa<FirstArgOwnershipForwardingSingleValueInst>(root)
-        || isa<OwnershipForwardingConversionInst>(root)
-        || isa<OwnershipForwardingSelectEnumInstBase>(root)
-        || isa<OwnershipForwardingMultipleValueInstruction>(root)) {
+    if (isa<FirstArgOwnershipForwardingSingleValueInst>(root) ||
+        isa<OwnershipForwardingConversionInst>(root) ||
+        isa<OwnershipForwardingSelectEnumInstBase>(root) ||
+        isa<OwnershipForwardingMultipleValueInstruction>(root)) {
       SILInstruction *inst = root->getDefiningInstruction();
 
       // The `enum` instruction can have no operand.

lib/SIL/Utils/OwnershipUtils.cpp

@@ -112,26 +112,26 @@ bool swift::canOpcodeForwardInnerGuaranteedValues(SILValue value) {
   if (auto *arg = dyn_cast<SILArgument>(value))
     if (auto *ti = arg->getSingleTerminator())
       if (ti->mayHaveTerminatorResult())
-        return OwnershipForwardingMixin::get(ti)->preservesOwnership();
+        return ForwardingInstruction::get(ti)->preservesOwnership();
 
   if (auto *inst = value->getDefiningInstruction())
-    if (auto *mixin = OwnershipForwardingMixin::get(inst))
+    if (auto *mixin = ForwardingInstruction::get(inst))
       return mixin->preservesOwnership() &&
              !isa<OwnedFirstArgForwardingSingleValueInst>(inst);
 
   return false;
 }
 
 bool swift::canOpcodeForwardInnerGuaranteedValues(Operand *use) {
-  if (auto *mixin = OwnershipForwardingMixin::get(use->getUser()))
+  if (auto *mixin = ForwardingInstruction::get(use->getUser()))
     return mixin->preservesOwnership() &&
            !isa<OwnedFirstArgForwardingSingleValueInst>(use->getUser());
   return false;
 }
 
 bool swift::canOpcodeForwardOwnedValues(SILValue value) {
   if (auto *inst = value->getDefiningInstructionOrTerminator()) {
-    if (auto *mixin = OwnershipForwardingMixin::get(inst)) {
+    if (auto *mixin = ForwardingInstruction::get(inst)) {
       return mixin->preservesOwnership() &&
              !isa<GuaranteedFirstArgForwardingSingleValueInst>(inst);
     }
@@ -141,7 +141,7 @@ bool swift::canOpcodeForwardOwnedValues(SILValue value) {
 
 bool swift::canOpcodeForwardOwnedValues(Operand *use) {
   auto *user = use->getUser();
-  if (auto *mixin = OwnershipForwardingMixin::get(user))
+  if (auto *mixin = ForwardingInstruction::get(user))
     return mixin->preservesOwnership() &&
            !isa<GuaranteedFirstArgForwardingSingleValueInst>(user);
   return false;
@@ -1733,12 +1733,12 @@ bool swift::visitForwardedGuaranteedOperands(
   if (inst->getNumRealOperands() == 0) {
     return false;
   }
-  if (isa<FirstArgOwnershipForwardingSingleValueInst>(inst)
-      || isa<OwnershipForwardingConversionInst>(inst)
-      || isa<OwnershipForwardingSelectEnumInstBase>(inst)
-      || isa<OwnershipForwardingMultipleValueInstruction>(inst)
-      || isa<MoveOnlyWrapperToCopyableValueInst>(inst)
-      || isa<CopyableToMoveOnlyWrapperValueInst>(inst)) {
+  if (isa<FirstArgOwnershipForwardingSingleValueInst>(inst) ||
+      isa<OwnershipForwardingConversionInst>(inst) ||
+      isa<OwnershipForwardingSelectEnumInstBase>(inst) ||
+      isa<OwnershipForwardingMultipleValueInstruction>(inst) ||
+      isa<MoveOnlyWrapperToCopyableValueInst>(inst) ||
+      isa<CopyableToMoveOnlyWrapperValueInst>(inst)) {
     assert(!isa<SingleValueInstruction>(inst)
            || !BorrowedValue(cast<SingleValueInstruction>(inst))
                   && "forwarded operand cannot begin a borrow scope");

lib/SIL/Verifier/SILVerifier.cpp

@@ -1306,7 +1306,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       }
     }
 
-    if (I->getFunction()->hasOwnership() && OwnershipForwardingMixin::isa(I)) {
+    if (I->getFunction()->hasOwnership() && ForwardingInstruction::isa(I)) {
       checkOwnershipForwardingInst(I);
     }
   }
@@ -1353,7 +1353,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   /// of its results, check forwarding invariants.
   void checkOwnershipForwardingInst(SILInstruction *i) {
     ValueOwnershipKind ownership =
-        OwnershipForwardingMixin::get(i)->getForwardingOwnershipKind();
+        ForwardingInstruction::get(i)->getForwardingOwnershipKind();
 
     if (auto *o = dyn_cast<OwnedFirstArgForwardingSingleValueInst>(i)) {
       ValueOwnershipKind kind = OwnershipKind::Owned;
@@ -1378,9 +1378,9 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     // representation. Non-destructive projection is allowed. Aggregation and
     // destructive disaggregation is not allowed. See SIL.rst, Forwarding
     // Addres-Only Values.
-    if (ownership == OwnershipKind::Guaranteed
-        && OwnershipForwardingMixin::isAddressOnly(i)) {
-      require(OwnershipForwardingMixin::hasSameRepresentation(i),
+    if (ownership == OwnershipKind::Guaranteed &&
+        ForwardingInstruction::isAddressOnly(i)) {
+      require(ForwardingInstruction::hasSameRepresentation(i),
               "Forwarding a guaranteed address-only value requires the same "
               "representation since no move or copy is allowed.");
     }