[ownership] Rename OwnershipForwardingMixin::{get,set}OwnershipKind() -> {get,set}ForwardingOwnershipKind().

TLDR: This is just an NFC rename in preparation for changing
SILValue::getOwnershipKind() of any forwarding instructions to return
OwnershipKind::None if they have a trivial result despite forwarding ownership
that isn't OwnershipKind::None (consider an unchecked_enum_data of a trivial
payload from a non-trivial enum).

This ensures that one does not by mistake use this routine instead of
SILValue::getOwnershipKind(). The reason why these two things must be
distinguished is that the forwarding ownership kind of an instruction that
inherits from OwnershipForwardingMixin is explicitly not the ValueOwnershipKind
of the result of the instruction. Instead it is a separate piece of state that:

1. For certain forwarding instructions, defines the OwnershipConstraint of the
forwarding instruction.

2. Defines the ownership kind of the result of the value. If the result of the
value is non-trivial then it is exactly the set ownership kind. If the result is
trivial, we use OwnershipKind::None instead. As an example of this, consider an
unchecked_enum_data that extracts from a non-trivial enum a trivial payload:

```
enum Either {
case int(Int)
case obj(Klass)
}

%1 = load_borrow %0 : $*Either
%2 = unchecked_enum_data %1 : $Either, #Either.int!enumelt.1 // Int type
end_borrow %1 : $Either
```

If we were to identify the forwarding ownership kind (guaranteed) of
unchecked_enum_data with the value ownership kind of its result, we would
violate ownership since we would be passing a guaranteed value to the operand of
the unchecked_enum_data that will only accept values with
OwnershipKind::None. =><=.

Author: gottesmm

include/swift/SIL/SILInstruction.h

@@ -1025,9 +1025,12 @@ class OwnershipForwardingMixin {
   }
 
 public:
-  ValueOwnershipKind getOwnershipKind() const { return ownershipKind; }
-
-  void setOwnershipKind(ValueOwnershipKind newKind) { ownershipKind = newKind; }
+  ValueOwnershipKind getForwardingOwnershipKind() const {
+    return ownershipKind;
+  }
+  void setForwardingOwnershipKind(ValueOwnershipKind newKind) {
+    ownershipKind = newKind;
+  }
 
   /// Defined inline below due to forward declaration issues.
   static OwnershipForwardingMixin *get(SILInstruction *inst);

lib/SIL/IR/OperandOwnership.cpp

@@ -299,8 +299,8 @@ OPERAND_OWNERSHIP(EndBorrow, AbortApply)
 #define FORWARDING_OWNERSHIP(INST)                                             \
   OperandOwnership OperandOwnershipClassifier::visit##INST##Inst(              \
       INST##Inst *i) {                                                         \
-    return i->getOwnershipKind().getForwardingOperandOwnership(         \
-      /*allowUnowned*/false);                                           \
+    return i->getForwardingOwnershipKind().getForwardingOperandOwnership(      \
+        /*allowUnowned*/ false);                                               \
   }
 FORWARDING_OWNERSHIP(Object)
 FORWARDING_OWNERSHIP(OpenExistentialRef)
@@ -318,8 +318,8 @@ FORWARDING_OWNERSHIP(LinearFunction)
 #define FORWARDING_ANY_OWNERSHIP(INST)                                         \
   OperandOwnership OperandOwnershipClassifier::visit##INST##Inst(              \
       INST##Inst *i) {                                                         \
-    return i->getOwnershipKind().getForwardingOperandOwnership(         \
-      /*allowUnowned*/true);                                            \
+    return i->getForwardingOwnershipKind().getForwardingOperandOwnership(      \
+        /*allowUnowned*/ true);                                                \
   }
 FORWARDING_ANY_OWNERSHIP(Upcast)
 FORWARDING_ANY_OWNERSHIP(UncheckedRefCast)
@@ -338,8 +338,8 @@ FORWARDING_ANY_OWNERSHIP(CheckedCastBranch)
 #define AGGREGATE_OWNERSHIP(INST)                                              \
   OperandOwnership OperandOwnershipClassifier::visit##INST##Inst(              \
       INST##Inst *i) {                                                         \
-    return i->getOwnershipKind().getForwardingOperandOwnership(         \
-      /*allowUnowned*/true);                                            \
+    return i->getForwardingOwnershipKind().getForwardingOperandOwnership(      \
+        /*allowUnowned*/ true);                                                \
   }
 AGGREGATE_OWNERSHIP(Tuple)
 AGGREGATE_OWNERSHIP(Struct)

lib/SIL/IR/ValueOwnership.cpp

@@ -241,7 +241,7 @@ ValueOwnershipKindClassifier::visitForwardingInst(SILInstruction *i,
 #define FORWARDING_OWNERSHIP_INST(INST)                                        \
   ValueOwnershipKind ValueOwnershipKindClassifier::visit##INST##Inst(          \
       INST##Inst *I) {                                                         \
-    return I->getOwnershipKind();                                              \
+    return I->getForwardingOwnershipKind();                                    \
   }
 FORWARDING_OWNERSHIP_INST(BridgeObjectToRef)
 FORWARDING_OWNERSHIP_INST(ConvertFunction)
@@ -258,6 +258,7 @@ FORWARDING_OWNERSHIP_INST(UncheckedValueCast)
 FORWARDING_OWNERSHIP_INST(UncheckedEnumData)
 FORWARDING_OWNERSHIP_INST(SelectEnum)
 FORWARDING_OWNERSHIP_INST(Enum)
+FORWARDING_OWNERSHIP_INST(MarkDependence)
 // NOTE: init_existential_ref from a reference counting perspective is not
 // considered to be "owned" since it doesn't affect reference counts. That being
 // said in the past, we wanted to conceptually treat it as an owned value that
@@ -312,12 +313,6 @@ ValueOwnershipKind ValueOwnershipKindClassifier::visitSILFunctionArgument(
   return Arg->getOwnershipKind();
 }
 
-// This is a forwarding instruction through only one of its arguments.
-ValueOwnershipKind
-ValueOwnershipKindClassifier::visitMarkDependenceInst(MarkDependenceInst *MDI) {
-  return MDI->getOwnershipKind();
-}
-
 ValueOwnershipKind ValueOwnershipKindClassifier::visitApplyInst(ApplyInst *ai) {
   auto *f = ai->getFunction();
   bool isTrivial = ai->getType().isTrivial(*f);

lib/SIL/Utils/OwnershipUtils.cpp

@@ -1081,26 +1081,26 @@ ValueOwnershipKind ForwardingOperand::getOwnershipKind() const {
   // in each if itself since we have an unreachable at the bottom to ensure if a
   // new subclass of OwnershipForwardingInst is added
   if (auto *ofsvi = dyn_cast<AllArgOwnershipForwardingSingleValueInst>(user))
-    return ofsvi->getOwnershipKind();
+    return ofsvi->getForwardingOwnershipKind();
 
   if (auto *ofsvi = dyn_cast<FirstArgOwnershipForwardingSingleValueInst>(user))
-    return ofsvi->getOwnershipKind();
+    return ofsvi->getForwardingOwnershipKind();
 
   if (auto *ofci = dyn_cast<OwnershipForwardingConversionInst>(user))
-    return ofci->getOwnershipKind();
+    return ofci->getForwardingOwnershipKind();
 
   if (auto *ofseib = dyn_cast<OwnershipForwardingSelectEnumInstBase>(user))
-    return ofseib->getOwnershipKind();
+    return ofseib->getForwardingOwnershipKind();
 
   if (auto *ofmvi =
           dyn_cast<OwnershipForwardingMultipleValueInstruction>(user)) {
     assert(ofmvi->getNumOperands() == 1);
-    return ofmvi->getOwnershipKind();
+    return ofmvi->getForwardingOwnershipKind();
   }
 
   if (auto *ofti = dyn_cast<OwnershipForwardingTermInst>(user)) {
     assert(ofti->getNumOperands() == 1);
-    return ofti->getOwnershipKind();
+    return ofti->getForwardingOwnershipKind();
   }
 
   llvm_unreachable("Unhandled forwarding inst?!");
@@ -1112,21 +1112,17 @@ void ForwardingOperand::setOwnershipKind(ValueOwnershipKind newKind) const {
   // in each if itself since we have an unreachable at the bottom to ensure if a
   // new subclass of OwnershipForwardingInst is added
   if (auto *ofsvi = dyn_cast<AllArgOwnershipForwardingSingleValueInst>(user))
-    if (!ofsvi->getType().isTrivial(*ofsvi->getFunction()))
-      return ofsvi->setOwnershipKind(newKind);
+    return ofsvi->setForwardingOwnershipKind(newKind);
   if (auto *ofsvi = dyn_cast<FirstArgOwnershipForwardingSingleValueInst>(user))
-    if (!ofsvi->getType().isTrivial(*ofsvi->getFunction()))
-      return ofsvi->setOwnershipKind(newKind);
+    return ofsvi->setForwardingOwnershipKind(newKind);
   if (auto *ofci = dyn_cast<OwnershipForwardingConversionInst>(user))
-    if (!ofci->getType().isTrivial(*ofci->getFunction()))
-      return ofci->setOwnershipKind(newKind);
+    return ofci->setForwardingOwnershipKind(newKind);
   if (auto *ofseib = dyn_cast<OwnershipForwardingSelectEnumInstBase>(user))
-    if (!ofseib->getType().isTrivial(*ofseib->getFunction()))
-      return ofseib->setOwnershipKind(newKind);
+    return ofseib->setForwardingOwnershipKind(newKind);
   if (auto *ofmvi = dyn_cast<OwnershipForwardingMultipleValueInstruction>(user)) {
     assert(ofmvi->getNumOperands() == 1);
     if (!ofmvi->getOperand(0)->getType().isTrivial(*ofmvi->getFunction())) {
-      ofmvi->setOwnershipKind(newKind);
+      ofmvi->setForwardingOwnershipKind(newKind);
       // TODO: Refactor this better.
       if (auto *dsi = dyn_cast<DestructureStructInst>(ofmvi)) {
         for (auto &result : dsi->getAllResultsBuffer()) {
@@ -1149,7 +1145,7 @@ void ForwardingOperand::setOwnershipKind(ValueOwnershipKind newKind) const {
   if (auto *ofti = dyn_cast<OwnershipForwardingTermInst>(user)) {
     assert(ofti->getNumOperands() == 1);
     if (!ofti->getOperand(0)->getType().isTrivial(*ofti->getFunction())) {
-      ofti->setOwnershipKind(newKind);
+      ofti->setForwardingOwnershipKind(newKind);
 
       // Then convert all of its incoming values that are owned to be guaranteed.
       for (auto &succ : ofti->getSuccessors()) {
@@ -1178,24 +1174,24 @@ void ForwardingOperand::replaceOwnershipKind(ValueOwnershipKind oldKind,
   auto *user = use->getUser();
 
   if (auto *fInst = dyn_cast<AllArgOwnershipForwardingSingleValueInst>(user))
-    if (fInst->getOwnershipKind() == oldKind)
-      return fInst->setOwnershipKind(newKind);
+    if (fInst->getForwardingOwnershipKind() == oldKind)
+      return fInst->setForwardingOwnershipKind(newKind);
 
   if (auto *fInst = dyn_cast<FirstArgOwnershipForwardingSingleValueInst>(user))
-    if (fInst->getOwnershipKind() == oldKind)
-      return fInst->setOwnershipKind(newKind);
+    if (fInst->getForwardingOwnershipKind() == oldKind)
+      return fInst->setForwardingOwnershipKind(newKind);
 
   if (auto *ofci = dyn_cast<OwnershipForwardingConversionInst>(user))
-    if (ofci->getOwnershipKind() == oldKind)
-      return ofci->setOwnershipKind(newKind);
+    if (ofci->getForwardingOwnershipKind() == oldKind)
+      return ofci->setForwardingOwnershipKind(newKind);
 
   if (auto *ofseib = dyn_cast<OwnershipForwardingSelectEnumInstBase>(user))
-    if (ofseib->getOwnershipKind() == oldKind)
-      return ofseib->setOwnershipKind(newKind);
+    if (ofseib->getForwardingOwnershipKind() == oldKind)
+      return ofseib->setForwardingOwnershipKind(newKind);
 
   if (auto *ofmvi = dyn_cast<OwnershipForwardingMultipleValueInstruction>(user)) {
-    if (ofmvi->getOwnershipKind() == oldKind) {
-      ofmvi->setOwnershipKind(newKind);
+    if (ofmvi->getForwardingOwnershipKind() == oldKind) {
+      ofmvi->setForwardingOwnershipKind(newKind);
     }
     // TODO: Refactor this better.
     if (auto *dsi = dyn_cast<DestructureStructInst>(ofmvi)) {
@@ -1216,8 +1212,8 @@ void ForwardingOperand::replaceOwnershipKind(ValueOwnershipKind oldKind,
   }
 
   if (auto *ofti = dyn_cast<OwnershipForwardingTermInst>(user)) {
-    if (ofti->getOwnershipKind() == oldKind) {
-      ofti->setOwnershipKind(newKind);
+    if (ofti->getForwardingOwnershipKind() == oldKind) {
+      ofti->setForwardingOwnershipKind(newKind);
       // Then convert all of its incoming values that are owned to be guaranteed.
       for (auto &succ : ofti->getSuccessors()) {
         auto *succBlock = succ.getBB();

lib/SIL/Verifier/SILVerifier.cpp

@@ -1161,14 +1161,14 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   void checkOwnershipForwardingInst(SILInstruction *i) {
     if (auto *o = dyn_cast<OwnedFirstArgForwardingSingleValueInst>(i)) {
       ValueOwnershipKind kind = OwnershipKind::Owned;
-      require(kind.isCompatibleWith(o->getOwnershipKind()),
+      require(kind.isCompatibleWith(o->getForwardingOwnershipKind()),
               "OwnedFirstArgForwardingSingleValueInst's ownership kind must be "
               "compatible with owned");
     }
 
     if (auto *o = dyn_cast<GuaranteedFirstArgForwardingSingleValueInst>(i)) {
       ValueOwnershipKind kind = OwnershipKind::Guaranteed;
-      require(kind.isCompatibleWith(o->getOwnershipKind()),
+      require(kind.isCompatibleWith(o->getForwardingOwnershipKind()),
               "GuaranteedFirstArgForwardingSingleValueInst's ownership kind "
               "must be compatible with guaranteed");
     }
@@ -2997,7 +2997,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       // 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();
+      auto parentKind = DSI->getForwardingOwnershipKind();
       for (const DestructureStructResult &result : DSI->getAllResultsBuffer()) {
         require(parentKind.isCompatibleWith(result.getOwnershipKind()),
                 "destructure result with ownership that is incompatible with "
@@ -3016,7 +3016,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       // 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();
+      auto parentKind = dti->getForwardingOwnershipKind();
       for (const auto &result : dti->getAllResultsBuffer()) {
         require(parentKind.isCompatibleWith(result.getOwnershipKind()),
                 "destructure result with ownership that is incompatible with "
@@ -4407,7 +4407,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
           if (!dest->getArgument(0)->getType().isTrivial(*SOI->getFunction())) {
             require(
                 dest->getArgument(0)->getOwnershipKind().isCompatibleWith(
-                    SOI->getOwnershipKind()),
+                    SOI->getForwardingOwnershipKind()),
                 "Switch enum non-trivial destination arg must have ownership "
                 "kind that is compatible with the switch_enum's operand");
           }

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -178,7 +178,8 @@ struct OwnershipModelEliminatorVisitor
 
 #define HANDLE_FORWARDING_INST(Cls)                                            \
   bool visit##Cls##Inst(Cls##Inst *i) {                                        \
-    OwnershipForwardingMixin::get(i)->setOwnershipKind(OwnershipKind::None);   \
+    OwnershipForwardingMixin::get(i)->setForwardingOwnershipKind(              \
+        OwnershipKind::None);                                                  \
     return true;                                                               \
   }
   HANDLE_FORWARDING_INST(ConvertFunction)
@@ -337,7 +338,7 @@ bool OwnershipModelEliminatorVisitor::visitDestroyValueInst(
 
 bool OwnershipModelEliminatorVisitor::visitCheckedCastBranchInst(
     CheckedCastBranchInst *cbi) {
-  cbi->setOwnershipKind(OwnershipKind::None);
+  cbi->setForwardingOwnershipKind(OwnershipKind::None);
 
   // In ownership qualified SIL, checked_cast_br must pass its argument to the
   // fail case so we can clean it up. In non-ownership qualified SIL, we expect
@@ -357,7 +358,7 @@ bool OwnershipModelEliminatorVisitor::visitCheckedCastBranchInst(
 
 bool OwnershipModelEliminatorVisitor::visitSwitchEnumInst(
     SwitchEnumInst *swei) {
-  swei->setOwnershipKind(OwnershipKind::None);
+  swei->setForwardingOwnershipKind(OwnershipKind::None);
 
   // In ownership qualified SIL, switch_enum must pass its argument to the fail
   // case so we can clean it up. In non-ownership qualified SIL, we expect no

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -741,7 +741,7 @@ SILCombiner::buildConcreteOpenedExistentialInfoFromSoleConformingType(
     // If we have an owned open_existential_ref, we only optimize for now if our
     // open_existential_ref has a single non-debug consuming use that is a
     // destroy_value.
-    if (OER->getOwnershipKind() != OwnershipKind::Owned) {
+    if (OER->getForwardingOwnershipKind() != OwnershipKind::Owned) {
       // We use OER as the insertion point so that
       SILBuilderWithScope b(std::next(OER->getIterator()), Builder);
       auto loc = RegularLocation::getAutoGeneratedLocation();

lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp

@@ -471,7 +471,7 @@ SILCombiner::visitUncheckedRefCastInst(UncheckedRefCastInst *urci) {
   // can remove both the open_existential_ref and the init_existential_ref.
   if (auto *oer = dyn_cast<OpenExistentialRefInst>(urci->getOperand())) {
     if (auto *ier = dyn_cast<InitExistentialRefInst>(oer->getOperand())) {
-      if (ier->getOwnershipKind() != OwnershipKind::Owned) {
+      if (ier->getForwardingOwnershipKind() != OwnershipKind::Owned) {
         return Builder.createUncheckedRefCast(urci->getLoc(), ier->getOperand(),
                                               urci->getType());
       }
@@ -735,8 +735,8 @@ SILCombiner::visitRawPointerToRefInst(RawPointerToRefInst *rawToRef) {
         // contrast, for guaranteed, we are replacing a BitwiseEscape use
         // (ref_to_rawpointer) with a ForwardedBorrowingUse (unchecked_ref_cast)
         // which is safe.
-        if (newInst->getOwnershipKind() == OwnershipKind::Owned) {
-          newInst->setOwnershipKind(OwnershipKind::Unowned);
+        if (newInst->getForwardingOwnershipKind() == OwnershipKind::Owned) {
+          newInst->setForwardingOwnershipKind(OwnershipKind::Unowned);
         }
         helper.perform(newInst);
         return nullptr;
@@ -825,8 +825,8 @@ visitUncheckedBitwiseCastInst(UncheckedBitwiseCastInst *UBCI) {
       // creating breaking OSSA. In contrast, if we have a guaranteed value, we
       // are going to be replacing an UnownedInstantaneousUse with an
       // InstantaneousUse which is always safe for a guaranteed value.
-      if (newInst->getOwnershipKind() == OwnershipKind::Owned) {
-        newInst->setOwnershipKind(OwnershipKind::Unowned);
+      if (newInst->getForwardingOwnershipKind() == OwnershipKind::Owned) {
+        newInst->setForwardingOwnershipKind(OwnershipKind::Unowned);
       }
       helper.perform(newInst);
       return nullptr;
@@ -1086,7 +1086,7 @@ SILCombiner::visitConvertFunctionInst(ConvertFunctionInst *cfi) {
     // We handle the case of an identity conversion in inst simplify, so if we
     // see this pattern then we know that we don't have a round trip and thus
     // should just bypass the intermediate conversion.
-    if (cfi->getOwnershipKind() != OwnershipKind::Owned) {
+    if (cfi->getForwardingOwnershipKind() != OwnershipKind::Owned) {
       cfi->getOperandRef().set(subCFI->getConverted());
       // Return cfi to show we changed it.
       return cfi;

lib/SILOptimizer/SemanticARC/OwnershipLiveRange.cpp

@@ -263,12 +263,12 @@ static SILValue convertIntroducerToGuaranteed(OwnedValueIntroducer introducer) {
   }
   case OwnedValueIntroducerKind::Struct: {
     auto *si = cast<StructInst>(introducer.value);
-    si->setOwnershipKind(OwnershipKind::Guaranteed);
+    si->setForwardingOwnershipKind(OwnershipKind::Guaranteed);
     return si;
   }
   case OwnedValueIntroducerKind::Tuple: {
     auto *ti = cast<TupleInst>(introducer.value);
-    ti->setOwnershipKind(OwnershipKind::Guaranteed);
+    ti->setForwardingOwnershipKind(OwnershipKind::Guaranteed);
     return ti;
   }
   case OwnedValueIntroducerKind::Copy: