[ownership] Make ForwardingOperand truly a loose wrapper around an operand.

This implies making -> and * return an Operand * instead of an
OwnershipForwardingInst. So one can thus do:

ForwardingOperand op;
op.myForwardingOperandMethod();
op->myOperandMethod();

include/swift/SIL/OwnershipUtils.h

@@ -82,29 +82,24 @@ class ForwardingOperand {
 public:
   static Optional<ForwardingOperand> get(Operand *use);
 
-  Operand *getUse() const { return use; }
   OwnershipConstraint getOwnershipConstraint() const {
     // We use a force unwrap since a ForwardingOperand should always have an
     // ownership constraint.
     return use->getOwnershipConstraint();
   }
+
   ValueOwnershipKind getOwnershipKind() const;
   void setOwnershipKind(ValueOwnershipKind newKind) const;
   void replaceOwnershipKind(ValueOwnershipKind oldKind,
                             ValueOwnershipKind newKind) const;
 
-  const OwnershipForwardingInst *operator->() const {
+  const Operand *operator->() const { return use; }
-    return cast<OwnershipForwardingInst>(use->getUser());
+
-  }
+  Operand *operator->() { return use; }
-  OwnershipForwardingInst *operator->() {
+
-    return cast<OwnershipForwardingInst>(use->getUser());
+  const Operand &operator*() const { return *use; }
-  }
+
-  const OwnershipForwardingInst &operator*() const {
+  Operand &operator*() { return *use; }
-    return *cast<OwnershipForwardingInst>(use->getUser());
-  }
-  OwnershipForwardingInst &operator*() {
-    return *cast<OwnershipForwardingInst>(use->getUser());
-  }
 
   /// Call \p visitor with each value that contains the final forwarded
   /// ownership of. E.x.: result of a unchecked_ref_cast, phi arguments of a

lib/SIL/Utils/OwnershipUtils.cpp

@@ -900,7 +900,35 @@ Optional<ForwardingOperand> ForwardingOperand::get(Operand *use) {
 }
 
 ValueOwnershipKind ForwardingOperand::getOwnershipKind() const {
-  return (*this)->getOwnershipKind();
+  auto *user = use->getUser();
+
+  // NOTE: This if chain is meant to be a covered switch, so make sure to return
+  // 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();
+
+  if (auto *ofsvi = dyn_cast<FirstArgOwnershipForwardingSingleValueInst>(user))
+    return ofsvi->getOwnershipKind();
+
+  if (auto *ofci = dyn_cast<OwnershipForwardingConversionInst>(user))
+    return ofci->getOwnershipKind();
+
+  if (auto *ofseib = dyn_cast<OwnershipForwardingSelectEnumInstBase>(user))
+    return ofseib->getOwnershipKind();
+
+  if (auto *ofmvi =
+          dyn_cast<OwnershipForwardingMultipleValueInstruction>(user)) {
+    assert(ofmvi->getNumOperands() == 1);
+    return ofmvi->getOwnershipKind();
+  }
+
+  if (auto *ofti = dyn_cast<OwnershipForwardingTermInst>(user)) {
+    assert(ofti->getNumOperands() == 1);
+    return ofti->getOwnershipKind();
+  }
+
+  llvm_unreachable("Unhandled forwarding inst?!");
 }
 
 void ForwardingOperand::setOwnershipKind(ValueOwnershipKind newKind) const {