Merge pull request #63578 from gottesmm/pr-e2a6558f3a5

[move-only] Prepare for handling ref_element_addr/global_addr/escaping closure captured params

Author: gottesmm

docs/SIL.rst

@@ -2660,7 +2660,7 @@ which codegens to the following SIL::
   bb0(%0 : @noImplicitCopy $Klass):
     %1 = copyable_to_moveonlywrapper [guaranteed] %0 : $@moveOnly Klass
     %2 = copy_value %1 : $@moveOnly Klass
-    %3 = mark_must_check [no_copy] %2 : $@moveOnly Klass
+    %3 = mark_must_check [no_consume_or_assign] %2 : $@moveOnly Klass
     debug_value %3 : $@moveOnly Klass, let, name "x", argno 1
     %4 = begin_borrow %3 : $@moveOnly Klass
     %5 = function_ref @$s4test5KlassC11doSomethingyyF : $@convention(method) (@guaranteed Klass) -> ()
@@ -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,8 +7823,8 @@ mark_must_check
   sil-instruction ::= 'mark_must_check'
                       '[' sil-optimizer-analysis-marker ']'
 
-  sil-optimizer-analysis-marker ::= 'no_implicit_copy'
-                                ::= 'no_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
 checker to check a specific value.  Valid only in Raw SIL. The relevant checkers
@@ -7833,10 +7833,10 @@ 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_copy``, then the move checker will validate that the
-result of this instruction is never consumed.
+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.
 
 No Implicit Copy and No Escape Value Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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,15 +8208,26 @@ 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 ot perform no copy checking. This
-    // forces the result of this instruction owned value to never be consumed
-    // (still allowing for non-consuming uses of course).
-    NoCopy,
+    /// 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
+    /// be consumed (for let/var semantics) or assigned over (for var
+    /// semantics). Of course, we still allow for non-consuming uses.
+    NoConsumeOrAssign,
+
+    /// A signal to the move checker that the given value cannot be consumed,
+    /// but is allowed to be assigned over. This is used for situations like
+    /// global_addr/ref_element_addr/closure escape where we do not want to
+    /// allow for the user to take the value (leaving the memory in an
+    /// uninitialized state), but we are ok with the user assigning a new value,
+    /// completely assigning over the value at once.
+    AssignableButNotConsumable,
   };
 
 private:
@@ -8239,8 +8250,9 @@ class MarkMustCheckInst
     switch (kind) {
     case CheckKind::Invalid:
       return false;
-    case CheckKind::NoImplicitCopy:
-    case CheckKind::NoCopy:
+    case CheckKind::ConsumableAndAssignable:
+    case CheckKind::NoConsumeOrAssign:
+    case CheckKind::AssignableButNotConsumable:
       return true;
     }
   }

lib/SIL/IR/SILPrinter.cpp

@@ -1992,11 +1992,14 @@ 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::NoCopy:
-      *this << "[no_copy] ";
+    case CheckKind::NoConsumeOrAssign:
+      *this << "[no_consume_or_assign] ";
+      break;
+    case CheckKind::AssignableButNotConsumable:
+      *this << "[assignable_but_not_consumable] ";
       break;
     }
     *this << getIDAndType(I->getOperand());

lib/SIL/Parser/ParseSIL.cpp

@@ -3661,10 +3661,13 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     }
 
     using CheckKind = MarkMustCheckInst::CheckKind;
-    CheckKind CKind = llvm::StringSwitch<CheckKind>(AttrName)
-                          .Case("no_implicit_copy", CheckKind::NoImplicitCopy)
-                          .Case("no_copy", CheckKind::NoCopy)
-                          .Default(CheckKind::Invalid);
+    CheckKind CKind =
+        llvm::StringSwitch<CheckKind>(AttrName)
+            .Case("consumable_and_assignable",
+                  CheckKind::ConsumableAndAssignable)
+            .Case("no_consume_or_assign", CheckKind::NoConsumeOrAssign)
+            .Case("assignable_but_not_consumable", CheckKind::AssignableButNotConsumable)
+            .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,15 +323,15 @@ 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;
       }
 
       assert(value->getOwnershipKind() == OwnershipKind::Guaranteed);
       value = SGF.B.createCopyValue(loc, value);
       value = SGF.B.createMarkMustCheckInst(
-          loc, value, MarkMustCheckInst::CheckKind::NoCopy);
+          loc, value, MarkMustCheckInst::CheckKind::NoConsumeOrAssign);
       SGF.emitManagedRValueWithCleanup(value);
       return value;
     }
@@ -341,9 +342,9 @@ struct ArgumentInitHelper {
 
       // If our argument was owned, we use no implicit copy. Otherwise, we
       // use no copy.
-      auto kind = MarkMustCheckInst::CheckKind::NoCopy;
+      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;
@@ -353,7 +354,7 @@ struct ArgumentInitHelper {
       value = SGF.B.createGuaranteedCopyableToMoveOnlyWrapperValue(loc, value);
       value = SGF.B.createCopyValue(loc, value);
       value = SGF.B.createMarkMustCheckInst(
-          loc, value, MarkMustCheckInst::CheckKind::NoCopy);
+          loc, value, MarkMustCheckInst::CheckKind::NoConsumeOrAssign);
       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;
     }
@@ -547,14 +548,14 @@ static void emitCaptureArguments(SILGenFunction &SGF,
       val = addr->getManagedAddress();
     }
 
-    // If this constant is a move only type, we need to add no_copy checking to
+    // If this constant is a move only type, we need to add no_consume_or_assign checking to
     // ensure that we do not consume this captured value in the function. This
     // is because closures can be invoked multiple times which is inconsistent
     // with consuming the move only type.
     if (val.getType().isMoveOnly()) {
       val = val.ensurePlusOne(SGF, Loc);
-      val = SGF.B.createMarkMustCheckInst(Loc, val,
-                                          MarkMustCheckInst::CheckKind::NoCopy);
+      val = SGF.B.createMarkMustCheckInst(
+          Loc, val, MarkMustCheckInst::CheckKind::NoConsumeOrAssign);
     }
 
     SGF.VarLocs[VD] = SILGenFunction::VarLoc::get(val.getValue());
@@ -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/MoveOnlyAddressChecker.cpp

@@ -1081,7 +1081,8 @@ bool GatherUsesVisitor::visitUse(Operand *op, AccessUseType useTy) {
     assert(op->getOperandNumber() == CopyAddrInst::Src &&
            "Should have dest above in memInstMust{Rei,I}nitialize");
 
-    if (markedValue->getCheckKind() == MarkMustCheckInst::CheckKind::NoCopy) {
+    if (markedValue->getCheckKind() ==
+        MarkMustCheckInst::CheckKind::NoConsumeOrAssign) {
       LLVM_DEBUG(llvm::dbgs()
                  << "Found mark must check [nocopy] error: " << *user);
       diagnosticEmitter.emitAddressDiagnosticNoCopy(markedValue, copyAddr);
@@ -1159,7 +1160,8 @@ bool GatherUsesVisitor::visitUse(Operand *op, AccessUseType useTy) {
       // If we are asked to perform guaranteed checking, emit an error if we
       // have /any/ consuming uses. This is a case that can always be converted
       // to a load_borrow if we pass the check.
-      if (markedValue->getCheckKind() == MarkMustCheckInst::CheckKind::NoCopy) {
+      if (markedValue->getCheckKind() ==
+          MarkMustCheckInst::CheckKind::NoConsumeOrAssign) {
         if (!moveChecker.canonicalizer.foundAnyConsumingUses()) {
           LLVM_DEBUG(llvm::dbgs()
                      << "Found mark must check [nocopy] error: " << *user);

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);