[move-function] Emit mark_unresolved_move_addr when we inline Builtin._move in a generic context.

This turns off the diagnostic that prevented the user from calling _move in such
contexts. I left that in for _copy.

Author: gottesmm

include/swift/SIL/SILBuilder.h

@@ -1271,10 +1271,11 @@ class SILBuilder {
                   MoveValueInst(getSILDebugLocation(loc), operand));
   }
 
-  MarkUnresolvedMoveAddrInst *createMarkUnresolvedMoveAddr(SILLocation loc, SILValue srcAddr,
-                                       SILValue takeAddr) {
-    return insert(new (getModule()) MarkUnresolvedMoveAddrInst(getSILDebugLocation(loc),
-                                                     srcAddr, takeAddr));
+  MarkUnresolvedMoveAddrInst *createMarkUnresolvedMoveAddr(SILLocation loc,
+                                                           SILValue srcAddr,
+                                                           SILValue takeAddr) {
+    return insert(new (getModule()) MarkUnresolvedMoveAddrInst(
+        getSILDebugLocation(loc), srcAddr, takeAddr));
   }
 
   UnconditionalCheckedCastInst *

include/swift/SIL/SILCloner.h

@@ -1342,11 +1342,12 @@ SILCloner<ImplClass>::visitCopyAddrInst(CopyAddrInst *Inst) {
 }
 
 template <typename ImplClass>
-void SILCloner<ImplClass>::visitMarkUnresolvedMoveAddrInst(MarkUnresolvedMoveAddrInst *Inst) {
+void SILCloner<ImplClass>::visitMarkUnresolvedMoveAddrInst(
+    MarkUnresolvedMoveAddrInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  auto *MVI = getBuilder().createMarkUnresolvedMoveAddr(getOpLocation(Inst->getLoc()),
-                                              getOpValue(Inst->getSrc()),
-                                              getOpValue(Inst->getDest()));
+  auto *MVI = getBuilder().createMarkUnresolvedMoveAddr(
+      getOpLocation(Inst->getLoc()), getOpValue(Inst->getSrc()),
+      getOpValue(Inst->getDest()));
   recordClonedInstruction(Inst, MVI);
 }
 

include/swift/SIL/SILInstruction.h

@@ -7439,7 +7439,7 @@ class MarkUnresolvedMoveAddrInst
   FixedOperandList<2> Operands;
 
   MarkUnresolvedMoveAddrInst(SILDebugLocation DebugLoc, SILValue srcAddr,
-                   SILValue takeAddr)
+                             SILValue takeAddr)
       : InstructionBase(DebugLoc), Operands(this, srcAddr, takeAddr) {}
 
 public:

lib/SIL/IR/SILInstruction.cpp

@@ -1167,8 +1167,8 @@ bool SILInstruction::mayRelease() const {
     return CopyAddr->isInitializationOfDest() ==
            IsInitialization_t::IsNotInitialization;
   }
-  // mark_unresolved_move_addr is equivalent to a copy_addr [init], so a release does not
-  // occur.
+  // mark_unresolved_move_addr is equivalent to a copy_addr [init], so a release
+  // does not occur.
   case SILInstructionKind::MarkUnresolvedMoveAddrInst:
     return false;
 

lib/SIL/Utils/MemoryLocations.cpp

@@ -367,8 +367,8 @@ bool MemoryLocations::analyzeLocationUsesRecursively(SILValue V, unsigned locIdx
         break;
       case SILInstructionKind::MarkUnresolvedMoveAddrInst:
         // We do not want the memory lifetime verifier to verify move_addr inst
-        // since the MarkUnresolvedMoveAddrChecker will validate that its uses are
-        // correct.
+        // since the MarkUnresolvedMoveAddrChecker will validate that its uses
+        // are correct.
         return false;
       default:
         return false;

lib/SIL/Verifier/LoadBorrowImmutabilityChecker.cpp

@@ -177,8 +177,8 @@ bool GatherWritesVisitor::visitUse(Operand *op, AccessUseType useTy) {
     }
 
     // This operand is the move source, we just return true. This is because
-    // mark_unresolved_move_addr semantically is treated as a copy_addr of the source. The
-    // checker determines if we can convert it to a move.
+    // mark_unresolved_move_addr semantically is treated as a copy_addr of the
+    // source. The checker determines if we can convert it to a move.
     return true;
 
   // If this value is dependent on another, conservatively consider it a write.

lib/SIL/Verifier/SILVerifier.cpp

@@ -593,9 +593,9 @@ struct ImmutableAddressUseVerifier {
       case SILInstructionKind::EndAccessInst:
         break;
       case SILInstructionKind::MarkUnresolvedMoveAddrInst:
-        // We model mark_unresolved_move_addr as a copy_addr [init]. So no mutation can
-        // happen. The checker will prove eventually that we can convert it to a
-        // copy_addr [take] [init].
+        // We model mark_unresolved_move_addr as a copy_addr [init]. So no
+        // mutation can happen. The checker will prove eventually that we can
+        // convert it to a copy_addr [take] [init].
         break;
       case SILInstructionKind::CopyAddrInst:
         if (isConsumingOrMutatingCopyAddrUse(use))

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -302,8 +302,8 @@ MemBehavior MemoryBehaviorVisitor::visitCopyAddrInst(CopyAddrInst *CAI) {
   return MemBehavior::None;
 }
 
-MemBehavior
-MemoryBehaviorVisitor::visitMarkUnresolvedMoveAddrInst(MarkUnresolvedMoveAddrInst *MAI) {
+MemBehavior MemoryBehaviorVisitor::visitMarkUnresolvedMoveAddrInst(
+    MarkUnresolvedMoveAddrInst *MAI) {
   bool mayWrite = mayAlias(MAI->getDest());
   bool mayRead = mayAlias(MAI->getSrc());
 

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -660,24 +660,27 @@ void SILInlineCloner::visitBuiltinInst(BuiltinInst *Inst) {
         auto otherResultAddr = getOpValue(Inst->getOperand(0));
         auto otherSrcAddr = getOpValue(Inst->getOperand(1));
         auto otherType = otherSrcAddr->getType();
-
-        if (!otherType.isLoadable(*Inst->getFunction())) {
-          // If otherType is not loadable, emit a diagnostic since it was used
-          // on a generic or existential value.
-          diagnose(Inst->getModule().getASTContext(),
-                   getOpLocation(Inst->getLoc()).getSourceLoc(),
-                   diag::move_operator_used_on_generic_or_existential_value);
-          return SILCloner<SILInlineCloner>::visitBuiltinInst(Inst);
-        }
+        auto opLoc = getOpLocation(Inst->getLoc());
 
         // If our otherType is loadable, convert it to move_value.
         getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-        // We stash otherValue in originalOtherValue in case we need to
-        // perform a writeback.
-        auto opLoc = getOpLocation(Inst->getLoc());
+
+        if (!otherType.isLoadable(*Inst->getFunction())) {
+          // If otherType is not loadable, convert the builtin to a
+          // mark_unresolved_move_addr. This builtin is a +1, but
+          // mark_unresolved_move_addr simulates a +0, so we put in our own
+          // destroy_addr.
+          getBuilder().createMarkUnresolvedMoveAddr(opLoc, otherSrcAddr,
+                                                    otherResultAddr);
+          getBuilder().createDestroyAddr(opLoc, otherSrcAddr);
+          auto *tup = getBuilder().createTuple(opLoc, {});
+          return recordFoldedValue(Inst, tup);
+        }
 
         assert(otherType.isAddress());
 
+        // We stash otherValue in originalOtherValue in case we need to
+        // perform a writeback.
         SILValue otherValue = getBuilder().emitLoadValueOperation(
             opLoc, otherSrcAddr, LoadOwnershipQualifier::Take);
 

lib/Serialization/DeserializeSIL.cpp

@@ -2107,8 +2107,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   case SILInstructionKind::MarkUnresolvedMoveAddrInst: {
     auto Ty = MF->getType(TyID);
     SILType addrType = getSILType(Ty, (SILValueCategory)TyCategory, Fn);
-    ResultInst = Builder.createMarkUnresolvedMoveAddr(Loc, getLocalValue(ValID, addrType),
-                                            getLocalValue(ValID2, addrType));
+    ResultInst = Builder.createMarkUnresolvedMoveAddr(
+        Loc, getLocalValue(ValID, addrType), getLocalValue(ValID2, addrType));
     break;
   }