[SIL] Added lexical flag to move_value.

The new flag will be used to track whether a move_value corresponds to a
source-level lexical scope. Here, the flag is just added to the
instruction and represented in textual and serialized SIL.

Author: nate-chandler

docs/SIL.rst

@@ -5280,7 +5280,7 @@ move_value
 
 ::
 
-   sil-instruction ::= 'move_value' sil-operand
+   sil-instruction ::= 'move_value' '[lexical]'? sil-operand
 
    %1 = move_value %0 : $@_moveOnly A
 
@@ -5303,6 +5303,9 @@ NOTE: This instruction is used in an experimental feature called 'move only
 values'. A move_value instruction is an instruction that introduces (or injects)
 a type `T` into the move only value space.
 
+The ``lexical`` attribute specifies that the value corresponds to a local
+variable in the Swift source.
+
 release_value
 `````````````
 

include/swift/SIL/SILBuilder.h

@@ -1263,12 +1263,13 @@ class SILBuilder {
                                                      operand, poisonRefs));
   }
 
-  MoveValueInst *createMoveValue(SILLocation loc, SILValue operand) {
+  MoveValueInst *createMoveValue(SILLocation loc, SILValue operand,
+                                 bool isLexical = false) {
     assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
            "emitMoveValueOperation");
-    return insert(new (getModule())
-                  MoveValueInst(getSILDebugLocation(loc), operand));
+    return insert(new (getModule()) MoveValueInst(getSILDebugLocation(loc),
+                                                  operand, isLexical));
   }
 
   MarkUnresolvedMoveAddrInst *createMarkUnresolvedMoveAddr(SILLocation loc,

include/swift/SIL/SILCloner.h

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

include/swift/SIL/SILInstruction.h

@@ -7457,13 +7457,17 @@ class MoveValueInst
   /// 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;
+  bool lexical = false;
 
-  MoveValueInst(SILDebugLocation DebugLoc, SILValue operand)
-      : UnaryInstructionBase(DebugLoc, operand, operand->getType()) {}
+  MoveValueInst(SILDebugLocation DebugLoc, SILValue operand, bool isLexical)
+      : UnaryInstructionBase(DebugLoc, operand, operand->getType()),
+        lexical(isLexical) {}
 
 public:
   bool getAllowDiagnostics() const { return allowDiagnostics; }
   void setAllowsDiagnostics(bool newValue) { allowDiagnostics = newValue; }
+
+  bool isLexical() const { return lexical; };
 };
 
 /// Equivalent to a copy_addr to [init] except that it is used for diagnostics

lib/SIL/IR/SILPrinter.cpp

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

lib/SIL/Parser/ParseSIL.cpp

@@ -3275,21 +3275,28 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
 
   case SILInstructionKind::MoveValueInst: {
     bool allowsDiagnostics = false;
+    bool isLexical = 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);
+    SourceLoc AttrLoc;
+    while (parseSILOptional(AttrName, AttrLoc, *this)) {
+      if (AttrName == "allows_diagnostics")
+        allowsDiagnostics = true;
+      else if (AttrName == "lexical")
+        isLexical = true;
+      else {
+        P.diagnose(InstLoc.getSourceLoc(),
+                   diag::sil_invalid_attribute_for_instruction, AttrName,
+                   "move_value");
         return true;
       }
-      allowsDiagnostics = true;
     }
 
     if (parseTypedValueRef(Val, B))
       return true;
     if (parseSILDebugLocation(InstLoc, B))
       return true;
-    auto *MVI = B.createMoveValue(InstLoc, Val);
+    auto *MVI = B.createMoveValue(InstLoc, Val, isLexical);
     MVI->setAllowsDiagnostics(allowsDiagnostics);
     ResultVal = MVI;
     break;

lib/Serialization/DeserializeSIL.cpp

@@ -1984,10 +1984,12 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
 
   case SILInstructionKind::MoveValueInst: {
     auto Ty = MF->getType(TyID);
-    auto AllowsDiagnostics = bool(Attr);
+    bool AllowsDiagnostics = Attr & 0x1;
+    bool IsLexical = (Attr >> 1) & 0x1;
     auto *MVI = Builder.createMoveValue(
         Loc,
-        getLocalValue(ValID, getSILType(Ty, (SILValueCategory)TyCategory, Fn)));
+        getLocalValue(ValID, getSILType(Ty, (SILValueCategory)TyCategory, Fn)),
+        IsLexical);
     MVI->setAllowsDiagnostics(AllowsDiagnostics);
     ResultInst = MVI;
     break;

lib/Serialization/SerializeSIL.cpp

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

test/SIL/Parser/basic2.sil

@@ -45,14 +45,22 @@ bb0(%0 : @owned $Builtin.NativeObject):
 }
 
 // CHECK-LABEL: sil [ossa] @test_movevalue_parsing : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
-// CHECK: bb0(%0 :
-// CHECK-NEXT: %1 = move_value %0 : $Builtin.NativeObject
-// CHECK-NEXT: return
+// CHECK: bb0([[REGISTER_0:%[^,]+]] :
+// CHECK-NEXT: [[REGISTER_1:%[^,]+]] = move_value [[REGISTER_0]]
+// CHECK-NEXT: [[REGISTER_2:%[^,]+]] = move_value [allows_diagnostics] [[REGISTER_1]]
+// CHECK-NEXT: [[REGISTER_3:%[^,]+]] = move_value [lexical] [[REGISTER_2]]
+// CHECK-NEXT: [[REGISTER_4:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_3]]
+// CHECK-NEXT: [[REGISTER_5:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_4]]
+// CHECK-NEXT: return [[REGISTER_5]]
 // CHECK-NEXT: } // end sil function 'test_movevalue_parsing'
 sil [ossa] @test_movevalue_parsing : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 bb0(%0 : @owned $Builtin.NativeObject):
   %1 = move_value %0 : $Builtin.NativeObject
-  return %1 : $Builtin.NativeObject
+  %2 = move_value [allows_diagnostics] %1 : $Builtin.NativeObject
+  %3 = move_value [lexical] %2 : $Builtin.NativeObject
+  %4 = move_value [allows_diagnostics] [lexical] %3 : $Builtin.NativeObject
+  %5 = move_value [lexical] [allows_diagnostics] %4 : $Builtin.NativeObject
+  return %5 : $Builtin.NativeObject
 }
 
 // CHECK-LABEL: sil @test_movevalue_parsing_non_ossa : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {

test/SIL/Serialization/basic.sil

@@ -69,16 +69,22 @@ bb0:
 }
 
 // CHECK-LABEL: sil [ossa] @test_movevalue_parsing : $@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: bb0([[REGISTER_0:%[^,]+]] :
+// CHECK-NEXT: [[REGISTER_1:%[^,]+]] = move_value [[REGISTER_0]]
+// CHECK-NEXT: [[REGISTER_2:%[^,]+]] = move_value [allows_diagnostics] [[REGISTER_1]]
+// CHECK-NEXT: [[REGISTER_3:%[^,]+]] = move_value [lexical] [[REGISTER_2]]
+// CHECK-NEXT: [[REGISTER_4:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_3]]
+// CHECK-NEXT: [[REGISTER_5:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_4]]
+// CHECK-NEXT: return [[REGISTER_5]]
 // CHECK-NEXT: } // end sil function 'test_movevalue_parsing'
 sil [ossa] @test_movevalue_parsing : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 bb0(%0 : @owned $Builtin.NativeObject):
   %1 = move_value %0 : $Builtin.NativeObject
   %2 = move_value [allows_diagnostics] %1 : $Builtin.NativeObject
-  return %2 : $Builtin.NativeObject
+  %3 = move_value [lexical] %2 : $Builtin.NativeObject
+  %4 = move_value [allows_diagnostics] [lexical] %3 : $Builtin.NativeObject
+  %5 = move_value [lexical] [allows_diagnostics] %4 : $Builtin.NativeObject
+  return %5 : $Builtin.NativeObject
 }
 
 // CHECK-LABEL: sil @test_movevalue_parsing_non_ossa : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {