[moveOnly] Allow for move_value to have an optional [allows_diagnostics] modifier.

This is a signal to the move value kill analysis that this is a move that should
have diagnostics emitted for it. It is a temporary addition until we add
MoveOnly to the SIL type system.

Author: gottesmm

include/swift/AST/DiagnosticsParse.def

@@ -633,6 +633,8 @@ ERROR(sil_keypath_index_operand_type_conflict,none,
 ERROR(sil_keypath_no_use_of_operand_in_pattern,none,
       "operand %0 is not referenced by any component in the pattern",
       (unsigned))
+ERROR(sil_movevalue_invalid_optional_attribute,none,
+      "Optional attribute '[%0]' can not be applied to move_value", (StringRef))
 
 // SIL Basic Blocks
 ERROR(expected_sil_block_name,none,

include/swift/SIL/SILCloner.h

@@ -1731,9 +1731,10 @@ void SILCloner<ImplClass>::visitExplicitCopyValueInst(
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitMoveValueInst(MoveValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  recordClonedInstruction(
-      Inst, getBuilder().createMoveValue(getOpLocation(Inst->getLoc()),
-                                         getOpValue(Inst->getOperand())));
+  auto *MVI = getBuilder().createMoveValue(getOpLocation(Inst->getLoc()),
+                                           getOpValue(Inst->getOperand()));
+  MVI->setAllowsDiagnostics(Inst->getAllowDiagnostics());
+  recordClonedInstruction(Inst, MVI);
 }
 
 template <typename ImplClass>

include/swift/SIL/SILInstruction.h

@@ -7337,8 +7337,17 @@ class MoveValueInst
                                   SingleValueInstruction> {
   friend class SILBuilder;
 
+  /// If set to true, we should emit the kill diagnostic for this move_value. If
+  /// set to false, we shouldn't emit such a diagnostic. This is a short term
+  /// addition until we get MoveOnly wrapper types into the SIL type system.
+  bool allowDiagnostics = false;
+
   MoveValueInst(SILDebugLocation DebugLoc, SILValue operand)
       : UnaryInstructionBase(DebugLoc, operand, operand->getType()) {}
+
+public:
+  bool getAllowDiagnostics() const { return allowDiagnostics; }
+  void setAllowsDiagnostics(bool newValue) { allowDiagnostics = newValue; }
 };
 
 /// Given an object reference, return true iff it is non-nil and refers

lib/SIL/IR/SILPrinter.cpp

@@ -1884,6 +1884,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   }
 
   void visitMoveValueInst(MoveValueInst *I) {
+    if (I->getAllowDiagnostics())
+      *this << "[allows_diagnostics] ";
     *this << getIDAndType(I->getOperand());
   }
 

lib/SIL/Parser/ParseSIL.cpp

@@ -3156,7 +3156,6 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     UNARY_INSTRUCTION(DestroyAddr)
     UNARY_INSTRUCTION(CopyValue)
     UNARY_INSTRUCTION(ExplicitCopyValue)
-    UNARY_INSTRUCTION(MoveValue)
     UNARY_INSTRUCTION(EndBorrow)
     UNARY_INSTRUCTION(DestructureStruct)
     UNARY_INSTRUCTION(DestructureTuple)
@@ -3266,6 +3265,28 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     break;
   }
 
+  case SILInstructionKind::MoveValueInst: {
+    bool allowsDiagnostics = false;
+    StringRef AttrName;
+    if (parseSILOptional(AttrName, *this)) {
+      if (!AttrName.equals("allows_diagnostics")) {
+        auto diag = diag::sil_movevalue_invalid_optional_attribute;
+        P.diagnose(InstLoc.getSourceLoc(), diag, AttrName);
+        return true;
+      }
+      allowsDiagnostics = true;
+    }
+
+    if (parseTypedValueRef(Val, B))
+      return true;
+    if (parseSILDebugLocation(InstLoc, B))
+      return true;
+    auto *MVI = B.createMoveValue(InstLoc, Val);
+    MVI->setAllowsDiagnostics(allowsDiagnostics);
+    ResultVal = MVI;
+    break;
+  }
+
   case SILInstructionKind::LoadInst: {
     Optional<LoadOwnershipQualifier> Qualifier;
     SourceLoc AddrLoc;

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -682,8 +682,10 @@ void SILInlineCloner::visitBuiltinInst(BuiltinInst *Inst) {
         SILValue otherValue = getBuilder().emitLoadValueOperation(
             opLoc, otherSrcAddr, LoadOwnershipQualifier::Take);
 
+        // Create a move_value and set that we want it to be used for diagnostic
+        // emission.
         auto *mvi = getBuilder().createMoveValue(opLoc, otherValue);
-
+        mvi->setAllowsDiagnostics(true);
         getBuilder().emitStoreValueOperation(opLoc, mvi, otherResultAddr,
                                              StoreOwnershipQualifier::Init);
 

lib/Serialization/DeserializeSIL.cpp

@@ -1867,7 +1867,6 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
   UNARY_INSTRUCTION(CopyValue)
   UNARY_INSTRUCTION(ExplicitCopyValue)
-  UNARY_INSTRUCTION(MoveValue)
   REFCOUNTING_INSTRUCTION(ReleaseValue)
   REFCOUNTING_INSTRUCTION(ReleaseValueAddr)
   REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
@@ -1984,6 +1983,17 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     break;
   }
 
+  case SILInstructionKind::MoveValueInst: {
+    auto Ty = MF->getType(TyID);
+    auto AllowsDiagnostics = bool(Attr);
+    auto *MVI = Builder.createMoveValue(
+        Loc,
+        getLocalValue(ValID, getSILType(Ty, (SILValueCategory)TyCategory, Fn)));
+    MVI->setAllowsDiagnostics(AllowsDiagnostics);
+    ResultInst = MVI;
+    break;
+  }
+
   case SILInstructionKind::LoadInst: {
     auto Ty = MF->getType(TyID);
     auto Qualifier = LoadOwnershipQualifier(Attr);

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 640; // @_typeSequence
+const uint16_t SWIFTMODULE_VERSION_MINOR = 641; // diagnostic move only
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SerializeSIL.cpp

@@ -1462,6 +1462,8 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
       Attr = ECMI->doKeepUnique();
     } else if (auto *BBI = dyn_cast<BeginBorrowInst>(&SI)) {
       Attr = BBI->isLexical();
+    } else if (auto *MVI = dyn_cast<MoveValueInst>(&SI)) {
+      Attr = MVI->getAllowDiagnostics();
     }
     writeOneOperandLayout(SI.getKind(), Attr, SI.getOperand(0));
     break;

test/SIL/Parser/basic2.sil

@@ -58,10 +58,12 @@ bb0(%0 : @owned $Builtin.NativeObject):
 // CHECK-LABEL: sil @test_movevalue_parsing_non_ossa : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 // CHECK: bb0(%0 :
 // CHECK-NEXT: %1 = move_value %0 : $Builtin.NativeObject
+// CHECK-NEXT: %2 = move_value [allows_diagnostics] %1 : $Builtin.NativeObject
 // CHECK-NEXT: return
 // CHECK-NEXT: } // end sil function 'test_movevalue_parsing_non_ossa'
 sil @test_movevalue_parsing_non_ossa : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 bb0(%0 : $Builtin.NativeObject):
   %1 = move_value %0 : $Builtin.NativeObject
-  return %1 : $Builtin.NativeObject
+  %2 = move_value [allows_diagnostics] %1 : $Builtin.NativeObject
+  return %2 : $Builtin.NativeObject
 }