[ownership] Centralize all info about SILInstruction forwarding in the SILInstruction class hierarchy itself.

This commit is doing a few things:

1. It is centralizing all decisions about whether an operand's owner instruction
or a value's parent instruction is forwarding in each SILInstruction
itself. This will prevent this information from getting out of sync.

2. This allowed me to hide the low level queries in OwnershipUtils.h that
determined if a SILNodeKind was "forwarding". I tried to minimize the amount of
churn in this PR and thus didn't remove the
is{Owned,Ownership,Guaranteed}Forwarding{Use,Value} checks. Instead I left them
alone but added in asserts to make sure that if the old impl ever returns true,
the neew impl does as well. In a subsequent commit, I am going to remove the old
impl in favor of isa queries.

3. I also in the process discovered that there were some instructions that were
being inconsistently marked as forwarding. All of the asserts in the PR caught
these and I fixed these inconsistencies.

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -32,33 +32,22 @@ class DeadEndBlocks;
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
 
-/// These operations forward both owned and guaranteed ownership.
-bool isOwnershipForwardingValueKind(SILNodeKind kind);
-
-/// Is this an operand that can forward both owned and guaranteed ownership
-/// kinds.
+/// Is this an operand that can forward both owned and guaranteed ownership into
+/// one of the operand's owner instruction's result.
 bool isOwnershipForwardingUse(Operand *op);
 
-/// Is this an operand that forwards guaranteed ownership from its value to a
-/// result of the using instruction.
+/// Is this an operand that can forward guaranteed ownership into one of the
+/// operand's owner instruction's result.
 bool isGuaranteedForwardingUse(Operand *op);
 
-/// These operations forward guaranteed ownership, but don't necessarily forward
-/// owned values.
-bool isGuaranteedForwardingValueKind(SILNodeKind kind);
+/// Is this an operand that can forward owned ownership into one of the
+/// operand's owner instruction's result.
+bool isOwnedForwardingUse(Operand *use);
 
-/// Is this a value that is the result of an operation that forwards owned
-/// ownership.
+/// Is this a value that is the result of an instruction that forwards
+/// guaranteed ownership from one of its operands.
 bool isGuaranteedForwardingValue(SILValue value);
 
-/// Is this a node kind that can forward owned ownership, but may not be able to
-/// forward guaranteed ownership.
-bool isOwnedForwardingValueKind(SILNodeKind kind);
-
-/// Does this operand 'forward' owned ownership, but may not be able to forward
-/// guaranteed ownership.
-bool isOwnedForwardingUse(Operand *use);
-
 /// Is this value the result of an instruction that 'forward's owned ownership,
 /// but may not be able to forward guaranteed ownership.
 ///
@@ -76,6 +65,11 @@ class ForwardingOperand {
   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,