Move getOwnershipKind from SILValue to ValueBase.

The API for values is on the ValueBase. SILValue is supposed to be a
pointer-like wrapper class. Accessing a value's API is always done as
'value->api()'. The ValueBase subclasses, like SingleValueInstruction,
need to inherit the API.

I didn't have time to fix all the cases of value.isOwnershipKind()
throughout the code.

Author: atrick

include/swift/SIL/SILValue.h

@@ -515,6 +515,16 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
   /// result index, or None if it is not defined by an instruction.
   Optional<DefiningInstructionResult> getDefiningInstructionResult();
 
+  /// Returns the ValueOwnershipKind that describes this SILValue's ownership
+  /// semantics if the SILValue has ownership semantics. Returns is a value
+  /// without any Ownership Semantics.
+  ///
+  /// An example of a SILValue without ownership semantics is a
+  /// struct_element_addr.
+  ///
+  /// NOTE: This is implemented in ValueOwnership.cpp not SILValue.cpp.
+  ValueOwnershipKind getOwnershipKind() const;
+
   static bool classof(SILNodePointer node) {
     return node->getKind() >= SILNodeKind::First_ValueBase &&
            node->getKind() <= SILNodeKind::Last_ValueBase;
@@ -592,6 +602,8 @@ class SILValue {
 
   /// If this SILValue is a result of an instruction, return its
   /// defining instruction. Returns nullptr otherwise.
+  ///
+  /// FIXME: remove this redundant API from SILValue.
   SILInstruction *getDefiningInstruction() {
     return Value->getDefiningInstruction();
   }
@@ -610,7 +622,11 @@ class SILValue {
   /// struct_element_addr.
   ///
   /// NOTE: This is implemented in ValueOwnership.cpp not SILValue.cpp.
-  ValueOwnershipKind getOwnershipKind() const;
+  ///
+  /// FIXME: remove this redundant API from SILValue.
+  ValueOwnershipKind getOwnershipKind() const {
+    return Value->getOwnershipKind();
+  }
 
   /// Verify that this SILValue and its uses respects ownership invariants.
   void verifyOwnership(DeadEndBlocks *DEBlocks) const;

lib/SIL/IR/ValueOwnership.cpp

@@ -586,15 +586,15 @@ ValueOwnershipKindClassifier::visitBuiltinInst(BuiltinInst *BI) {
 //                            Top Level Entrypoint
 //===----------------------------------------------------------------------===//
 
-ValueOwnershipKind SILValue::getOwnershipKind() const {
+ValueOwnershipKind ValueBase::getOwnershipKind() const {
   // If we do not have an undef, we should always be able to get to our function
   // here. If we do not have ownership enabled, just return none for everything
   // to short circuit ownership optimizations. Since SILUndef in either case
   // will be ValueOwnershipKind::None, we will not get any wonky behavior here.
   //
   // We assume that any time we are in SILBuilder and call this without having a
   // value in a block yet, ossa is enabled.
-  if (auto *block = Value->getParentBlock()) {
+  if (auto *block = getParentBlock()) {
     auto *f = block->getParent();
     // If our block isn't in a function, then it must be in a global
     // variable. We don't verify ownership there so just return
@@ -609,7 +609,7 @@ ValueOwnershipKind SILValue::getOwnershipKind() const {
   }
 
   ValueOwnershipKindClassifier Classifier;
-  auto result = Classifier.visit(const_cast<ValueBase *>(Value));
+  auto result = Classifier.visit(const_cast<ValueBase *>(this));
   assert(result && "Returned ownership kind invalid on values");
   return result;
 }