[move-only] Rename CheckKind::NoImplicitCopy -> CheckKind::ConsumableAndAssignable

This fits the name of the check better. The reason I am doing this renaming is
b/c I am going to add a nonconsumable but assignable check for
global_addr/ref_element_addr/captures with var semantics.

Author: gottesmm

docs/SIL.rst

@@ -2730,7 +2730,7 @@ Today this codegens to the following Swift::
   bb0(%0 : @noImplicitCopy $Int):
     %1 = copyable_to_moveonlywrapper [owned] %0 : $Int
     %2 = move_value [lexical] %1 : $@moveOnly Int
-    %3 = mark_must_check [no_implicit_copy] %2 : $@moveOnly Int
+    %3 = mark_must_check [consumable_and_assignable] %2 : $@moveOnly Int
     %5 = begin_borrow %3 : $@moveOnly Int
     %6 = begin_borrow %3 : $@moveOnly Int
     %7 = function_ref @addIntegers : $@convention(method) (Int, Int Int.Type) -> Int
@@ -2789,7 +2789,7 @@ A hypothetical SILGen for this code is as follows::
     %3 = begin_borrow [lexical] %0 : $Klass
     %4 = copy_value %3 : $Klass
     %5 = copyable_to_moveonlywrapper [owned] %4 : $Klass
-    %6 = mark_must_check [no_implicit_copy] %5 : $@moveOnly Klass
+    %6 = mark_must_check [consumable_and_assignable] %5 : $@moveOnly Klass
     debug_value %6 : $@moveOnly Klass, let, name "value"
     %8 = begin_borrow %6 : $@moveOnly Klass
     %9 = copy_value %8 : $@moveOnly Klass
@@ -7823,7 +7823,7 @@ mark_must_check
   sil-instruction ::= 'mark_must_check'
                       '[' sil-optimizer-analysis-marker ']'
 
-  sil-optimizer-analysis-marker ::= 'no_implicit_copy'
+  sil-optimizer-analysis-marker ::= 'consumable_and_assignable'
                                 ::= 'no_consume_or_assign'
 
 A canary value inserted by a SIL generating frontend to signal to the move
@@ -7833,7 +7833,7 @@ relevant diagnostic. The idea here is that instead of needing to introduce
 multiple "flagging" instructions for the optimizer, we can just reuse this one
 instruction by varying the kind.
 
-If the sil optimizer analysis marker is ``no_implicit_copy`` then the move
+If the sil optimizer analysis marker is ``consumable_and_assignable`` then the move
 checker is told to check that the result of this instruction is consumed at most
 once. If the marker is ``no_consume_or_assign``, then the move checker will
 validate that the result of this instruction is never consumed or assigned over.

include/swift/AST/DiagnosticsSIL.def

@@ -767,7 +767,7 @@ NOTE(sil_moveonlychecker_nonconsuming_use_here, none,
 NOTE(sil_movekillscopyablevalue_value_cyclic_consumed_in_loop_here, none,
      "consuming in loop use here", ())
 
-ERROR(sil_moveonlychecker_not_understand_no_implicit_copy, none,
+ERROR(sil_moveonlychecker_not_understand_consumable_and_assignable, none,
       "Usage of @noImplicitCopy that the move checker does not know how to "
       "check!", ())
 ERROR(sil_moveonlychecker_not_understand_moveonly, none,

include/swift/SIL/SILInstruction.h

@@ -8208,10 +8208,12 @@ class MarkMustCheckInst
   enum class CheckKind : unsigned {
     Invalid = 0,
 
-    // A signal to the move only checker to perform no implicit copy checking on
-    // the result of this instruction. This implies that the result can be
-    // consumed at most once.
-    NoImplicitCopy,
+    // A signal to the move only checker to perform checking that allows for
+    // this value to be consumed along its boundary (in the case of let/var
+    // semantics) and also written over in the case of var semantics. NOTE: Of
+    // course this still implies the value cannot be copied and can be consumed
+    // only once along all program paths.
+    ConsumableAndAssignable,
 
     // A signal to the move only checker to perform no consume or assign
     // checking. This forces the result of this instruction owned value to never
@@ -8240,7 +8242,7 @@ class MarkMustCheckInst
     switch (kind) {
     case CheckKind::Invalid:
       return false;
-    case CheckKind::NoImplicitCopy:
+    case CheckKind::ConsumableAndAssignable:
     case CheckKind::NoConsumeOrAssign:
       return true;
     }

lib/SIL/IR/SILPrinter.cpp

@@ -1992,8 +1992,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     switch (I->getCheckKind()) {
     case CheckKind::Invalid:
       llvm_unreachable("Invalid?!");
-    case CheckKind::NoImplicitCopy:
-      *this << "[no_implicit_copy] ";
+    case CheckKind::ConsumableAndAssignable:
+      *this << "[consumable_and_assignable] ";
       break;
     case CheckKind::NoConsumeOrAssign:
       *this << "[no_consume_or_assign] ";

lib/SIL/Parser/ParseSIL.cpp

@@ -3661,10 +3661,12 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     }
 
     using CheckKind = MarkMustCheckInst::CheckKind;
-    CheckKind CKind = llvm::StringSwitch<CheckKind>(AttrName)
-                          .Case("no_implicit_copy", CheckKind::NoImplicitCopy)
-                          .Case("no_consume_or_assign", CheckKind::NoConsumeOrAssign)
-                          .Default(CheckKind::Invalid);
+    CheckKind CKind =
+        llvm::StringSwitch<CheckKind>(AttrName)
+            .Case("consumable_and_assignable",
+                  CheckKind::ConsumableAndAssignable)
+            .Case("no_consume_or_assign", CheckKind::NoConsumeOrAssign)
+            .Default(CheckKind::Invalid);
 
     if (CKind == CheckKind::Invalid) {
       auto diag = diag::sil_markmustcheck_invalid_attribute;

lib/SILGen/SILGenConstructor.cpp

@@ -839,7 +839,8 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
       if (selfArg.getType().isMoveOnly()) {
         assert(selfArg.getOwnershipKind() == OwnershipKind::Owned);
         selfArg = B.createMarkMustCheckInst(
-            selfDecl, selfArg, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+            selfDecl, selfArg,
+            MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
       }
       VarLocs[selfDecl] = VarLoc::get(selfArg.getValue());
     }

lib/SILGen/SILGenDecl.cpp

@@ -380,7 +380,7 @@ class LocalVariableInitialization : public SingleBufferInitialization {
     if (Addr->getType().isMoveOnly()) {
       // TODO: Handle no implicit copy here.
       Addr = SGF.B.createMarkMustCheckInst(
-          decl, Addr, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          decl, Addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
     }
 
     // Push a cleanup to destroy the local variable.  This has to be
@@ -580,7 +580,8 @@ class LetValueInitialization : public Initialization {
       if (value->getType().isPureMoveOnly()) {
         value = SGF.B.createMoveValue(PrologueLoc, value, /*isLexical*/ true);
         return SGF.B.createMarkMustCheckInst(
-            PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+            PrologueLoc, value,
+            MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
       }
 
       // Otherwise, if we don't have a no implicit copy trivial type, just
@@ -594,7 +595,8 @@ class LetValueInitialization : public Initialization {
           SGF.B.createOwnedCopyableToMoveOnlyWrapperValue(PrologueLoc, value);
       value = SGF.B.createMoveValue(PrologueLoc, value, /*isLexical*/ true);
       return SGF.B.createMarkMustCheckInst(
-          PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          PrologueLoc, value,
+          MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
     }
 
     // Then if we don't have move only, just perform a lexical borrow if the
@@ -636,7 +638,8 @@ class LetValueInitialization : public Initialization {
         !value->getType().isMoveOnlyWrapped()) {
       value = SGF.B.createMoveValue(PrologueLoc, value, true /*isLexical*/);
       return SGF.B.createMarkMustCheckInst(
-          PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          PrologueLoc, value,
+          MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
     }
 
     // Otherwise, if we do not have a no implicit copy variable, just follow
@@ -655,7 +658,8 @@ class LetValueInitialization : public Initialization {
     value = SGF.B.createCopyValue(PrologueLoc, value);
     value = SGF.B.createOwnedCopyableToMoveOnlyWrapperValue(PrologueLoc, value);
     return SGF.B.createMarkMustCheckInst(
-        PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+        PrologueLoc, value,
+        MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
   }
 
   void bindValue(SILValue value, SILGenFunction &SGF, bool wasPlusOne) {

lib/SILGen/SILGenProlog.cpp

@@ -49,7 +49,8 @@ SILValue SILGenFunction::emitSelfDeclForDestructor(VarDecl *selfDecl) {
     // they cannot escape.
     if (selfValue->getOwnershipKind() == OwnershipKind::Owned) {
       selfValue = B.createMarkMustCheckInst(
-          selfDecl, selfValue, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          selfDecl, selfValue,
+          MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
     }
   }
 
@@ -129,7 +130,7 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
       // check ownership.
       if (mv.getType().isMoveOnly() && !mv.getType().isMoveOnlyWrapped())
         mv = SGF.B.createMarkMustCheckInst(
-            loc, mv, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+            loc, mv, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
       return mv;
     }
 
@@ -322,7 +323,7 @@ struct ArgumentInitHelper {
         value = SGF.B.createMoveValue(loc, argrv.forward(SGF),
                                       /*isLexical*/ true);
         value = SGF.B.createMarkMustCheckInst(
-            loc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+            loc, value, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
         SGF.emitManagedRValueWithCleanup(value);
         return value;
       }
@@ -343,7 +344,7 @@ struct ArgumentInitHelper {
       // use no copy.
       auto kind = MarkMustCheckInst::CheckKind::NoConsumeOrAssign;
       if (pd->isOwned())
-        kind = MarkMustCheckInst::CheckKind::NoImplicitCopy;
+        kind = MarkMustCheckInst::CheckKind::ConsumableAndAssignable;
       value = SGF.B.createMarkMustCheckInst(loc, value, kind);
       SGF.emitManagedRValueWithCleanup(value);
       return value;
@@ -365,7 +366,7 @@ struct ArgumentInitHelper {
           loc, argrv.forward(SGF));
       value = SGF.B.createMoveValue(loc, value, true /*is lexical*/);
       value = SGF.B.createMarkMustCheckInst(
-          loc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          loc, value, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
       SGF.emitManagedRValueWithCleanup(value);
       return value;
     }
@@ -585,7 +586,7 @@ static void emitCaptureArguments(SILGenFunction &SGF,
     SILValue addr = SGF.B.createProjectBox(VD, box, 0);
     if (addr->getType().isMoveOnly())
       addr = SGF.B.createMarkMustCheckInst(
-          VD, addr, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          VD, addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
     SGF.VarLocs[VD] = SILGenFunction::VarLoc::get(addr, box);
     SILDebugVariable DbgVar(VD->isLet(), ArgNo);
     SGF.B.createDebugValueAddr(Loc, addr, DbgVar);
@@ -608,7 +609,7 @@ static void emitCaptureArguments(SILGenFunction &SGF,
     SILValue arg = SILValue(fArg);
     if (isInOut && (ty.isMoveOnly() && !ty.isMoveOnlyWrapped())) {
       arg = SGF.B.createMarkMustCheckInst(
-          Loc, arg, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+          Loc, arg, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
     }
     SGF.VarLocs[VD] = SILGenFunction::VarLoc::get(arg);
     SILDebugVariable DbgVar(VD->isLet(), ArgNo);

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -95,8 +95,9 @@ void DiagnosticEmitter::emitCheckerDoesntUnderstandDiagnostic(
   // that copy propagation did not understand. Emit a we did not understand
   // error.
   if (markedValue->getType().isMoveOnlyWrapped()) {
-    diagnose(fn->getASTContext(), markedValue,
-             diag::sil_moveonlychecker_not_understand_no_implicit_copy);
+    diagnose(
+        fn->getASTContext(), markedValue,
+        diag::sil_moveonlychecker_not_understand_consumable_and_assignable);
   } else {
     diagnose(fn->getASTContext(), markedValue,
              diag::sil_moveonlychecker_not_understand_moveonly);

lib/SILOptimizer/Mandatory/MoveOnlyObjectChecker.cpp

@@ -94,7 +94,7 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
       // This is forming a let or an argument.
       // bb0:
       //   %1 = move_value [lexical] %0
-      //   %2 = mark_must_check [no_implicit_copy] %1
+      //   %2 = mark_must_check [consumable_and_assignable] %1
       //
       // This occurs when SILGen materializes a temporary move only value?
       // bb0:
@@ -170,7 +170,7 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
       // bb0(%0 : $Trivial):
       //  %1 = copyable_to_moveonlywrapper [owned] %0
       //  %2 = move_value [lexical] %1
-      //  %3 = mark_must_check [no_implicit_copy] %2
+      //  %3 = mark_must_check [consumable_and_assignable] %2
       //
       // *OR*
       //
@@ -202,7 +202,7 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
       // bb0(%0 : @owned $T):
       //   %1 = copyable_to_moveonlywrapper [owned] %0
       //   %2 = move_value [lexical] %1
-      //   %3 = mark_must_check [no_implicit_copy_owned] %2
+      //   %3 = mark_must_check [consumable_and_assignable_owned] %2
       if (auto *mvi = dyn_cast<MoveValueInst>(mmci->getOperand())) {
         if (mvi->isLexical()) {
           if (auto *cvt = dyn_cast<CopyableToMoveOnlyWrapperValueInst>(
@@ -224,7 +224,7 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
       //  %1 = begin_borrow [lexical] %0
       //  %2 = copy_value %1
       //  %3 = copyable_to_moveonlywrapper [owned] %2
-      //  %4 = mark_must_check [no_implicit_copy]
+      //  %4 = mark_must_check [consumable_and_assignable]
       //
       // Or for a move only type, we look for a move_value [lexical].
       if (auto *mvi = dyn_cast<CopyableToMoveOnlyWrapperValueInst>(
@@ -245,7 +245,7 @@ bool swift::siloptimizer::searchForCandidateObjectMarkMustChecks(
       //
       // %1 = copyable_to_moveonlywrapper [owned] %0
       // %2 = move_value [lexical] %1
-      // %3 = mark_must_check [no_implicit_copy] %2
+      // %3 = mark_must_check [consumable_and_assignable] %2
       if (auto *cvi = dyn_cast<ExplicitCopyValueInst>(mmci->getOperand())) {
         if (auto *bbi = dyn_cast<BeginBorrowInst>(cvi->getOperand())) {
           if (bbi->isLexical()) {