[ownership] Change canFixUpOwnershipForRAUW so that 'oldValue' is a SILValue not a SingleValueInstruction

The only operational change here is that I needed to be able to grab the module
from the SILValue so I could see if we were in Raw SIL or not. I realized the
only case where we could not get the module is from SILUndef and at this point
in the code we know we are going to bail already for SILUndef. This is because
we already know our new value doesn't have OwnershipKind::None and we don't
replace OwnershipKind::None things with non-OwnershipKind::None things since I
haven't implemented support for that corner case yet (but will with time).

Once I realized the previous paragraph, I was able to add support without issue.

Author: gottesmm

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -52,8 +52,7 @@ struct OwnershipFixupContext {
   /// Namely, we do not support RAUWing values with ValueOwnershipKind::None
   /// that have uses that do not require ValueOwnershipKind::None or
   /// ValueOwnershipKind::Any.
-  static bool canFixUpOwnershipForRAUW(const SingleValueInstruction *oldValue,
-                                       SILValue newValue);
+  static bool canFixUpOwnershipForRAUW(SILValue oldValue, SILValue newValue);
 };
 
 } // namespace swift

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -721,11 +721,11 @@ SILBasicBlock::iterator OwnershipRAUWUtility::perform() {
 //===----------------------------------------------------------------------===//
 //                          Ownership Fixup Context
 //===----------------------------------------------------------------------===//
-//
-// Top level entry points to RAUW code.
-//
-bool OwnershipFixupContext::canFixUpOwnershipForRAUW(
-    const SingleValueInstruction *oldValue, SILValue newValue) {
+
+// All callers of our RAUW routines must ensure that their values return true
+// from this.
+bool OwnershipFixupContext::canFixUpOwnershipForRAUW(SILValue oldValue,
+                                                     SILValue newValue) {
   auto newOwnershipKind = newValue.getOwnershipKind();
 
   // If our new kind is ValueOwnershipKind::None, then we are fine. We
@@ -734,9 +734,26 @@ bool OwnershipFixupContext::canFixUpOwnershipForRAUW(
   if (newOwnershipKind == OwnershipKind::None)
     return true;
 
+  // First check if oldValue is SILUndef. If it is, then we know that:
+  //
+  // 1. SILUndef (and thus oldValue) must have OwnershipKind::None.
+  // 2. newValue is not OwnershipKind::None due to our check above.
+  //
+  // Thus we know that we would be replacing a value with OwnershipKind::None
+  // with a value with non-None ownership. This is a case we don't support, so
+  // we can bail now.
+  if (isa<SILUndef>(oldValue))
+    return false;
+
+  // Ok, we now know that we do not have SILUndef implying that we must be able
+  // to get a module from our value since we must have an argument or an
+  // instruction.
+  auto *m = oldValue->getModule();
+  assert(m);
+
   // If we are in Raw SIL, just bail at this point. We do not support
   // ownership fixups.
-  if (oldValue->getModule().getStage() == SILStage::Raw)
+  if (m->getStage() == SILStage::Raw)
     return false;
 
   // If our old ownership kind is ValueOwnershipKind::None and our new kind is