[moveOnly] Add a new experimental move only checker that checks noImplicitCopy variables.

NOTE: This is only available when the flag -enable-experimental-move-only. There
are no effects when the flag is disabled.

The way that this works is that it takes advantage of the following changes to
SILGen emission:

* When SILGen initializes a let with NoImplicitCopyAttribute, SILGen now emits
a begin_borrow [lexical] + copy + move_only. This is a pattern that we can check
and know that we are processing a move only value. When performing move
checking, we check move_only as a move only value and that it isn't consumed
multiple times.

* The first point works well for emitting all diagnostics except for
initializing an additional let var. To work around that I changed let
initialization to always bind to an owned value to a move of that owned
value. There is no semantic difference since that value is going to be consumed
by the binding operation anyways so we effectively just move the cleanup from
the original value we wanted to bind to the move. We still then actually borrow
the new let value with a begin_borrow [lexical] for the new let value. This
ensures that an initialization of a let value appears to be a consuming use to
the move only value checker while ensuring that the value has a proper
begin_borrow [lexical].

Some notes on functionality:

1. This attribute can only be applied to local 'let'.

2. "print" due to how we call it today with a vararg array is treated as a
   consuming use (unfortunately).

3. I have not added the builtin copy operator yet, but I recently added a _move
   skeleton attribute so one can end the lifetimes of these values early.

4. This supports all types that are not address only types (similar to
   _move). To support full on address only types we need opaque values.

rdar://83957088

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -690,5 +690,16 @@ NOTE(capturepromotion_variable_defined_here,none,
 ERROR(move_operator_used_on_generic_or_existential_value, none,
       "move() used on a generic or existential value", ())
 
+// noimplicitcopy on generic or existential binding
+ERROR(noimplicitcopy_used_on_generic_or_existential, none,
+      "@_noImplicitCopy can not be used on a generic or existential typed "
+      "binding or a nominal type containing such typed things", ())
+
+// move only checker diagnostics
+ERROR(sil_moveonlychecker_value_consumed_more_than_once, none,
+      "'%0' consumed more than once", (StringRef))
+NOTE(sil_moveonlychecker_consuming_use_here, none,
+     "consuming use", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/SIL/DebugUtils.h

@@ -174,6 +174,18 @@ inline SILInstruction *getSingleNonDebugUser(SILValue V) {
   return I->getUser();
 }
 
+/// If \p value has a single debug user, return the operand associated with that
+/// use. Otherwise, returns nullptr.
+inline Operand *getSingleDebugUse(SILValue value) {
+  auto range = getDebugUses(value);
+  auto ii = range.begin(), ie = range.end();
+  if (ii == ie)
+    return nullptr;
+  if (std::next(ii) != ie)
+    return nullptr;
+  return *ii;
+}
+
 /// Erases the instruction \p I from it's parent block and deletes it, including
 /// all debug instructions which use \p I.
 /// Precondition: The instruction may only have debug instructions as uses.

include/swift/SILOptimizer/PassManager/Passes.def

@@ -416,6 +416,8 @@ PASS(BugReducerTester, "bug-reducer-tester",
      "sil-bug-reducer Tool Testing by Asserting on a Sentinel Function")
 PASS(AssemblyVisionRemarkGenerator, "assembly-vision-remark-generator",
      "Emit assembly vision remarks that provide source level guidance of where runtime calls ended up")
+PASS(MoveOnlyChecker, "sil-move-only-checker",
+     "Pass that enforces move only invariants on raw SIL")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -114,6 +114,13 @@ extern llvm::Statistic NumCopiesGenerated;
 /// Insert a copy on this operand. Trace and update stats.
 void copyLiveUse(Operand *use, InstModCallbacks &instModCallbacks);
 
+/// Diagnose that the given value is a move only type for which \p use causes a
+/// need to copy the move only value.
+///
+/// copy on this operand. Trace and update stats.
+void diagnoseRequiredCopyOfMoveOnly(Operand *use,
+                                    InstModCallbacks &instModCallbacks);
+
 /// Information about consumes on the extended-lifetime boundary. Consuming uses
 /// within the lifetime are not included--they will consume a copy after
 /// rewriting. For borrowed def values, the consumes do not include the end of
@@ -244,6 +251,15 @@ class CanonicalizeOSSALifetime {
   /// If true, then new destroy_value instructions will be poison.
   bool poisonRefsMode;
 
+  /// If true and we are processing a value of move_only type, emit a diagnostic
+  /// when-ever we need to insert a copy_value.
+  std::function<void(Operand *)> moveOnlyCopyValueNotification;
+
+  /// If true and we are processing a value of move_only type, pass back to the
+  /// caller any consuming uses that are going to be used as part of the final
+  /// lifetime boundary in case we need to emit diagnostics.
+  std::function<void(Operand *)> moveOnlyFinalConsumingUse;
+
   NonLocalAccessBlockAnalysis *accessBlockAnalysis;
   // Lazily initialize accessBlocks only when
   // extendLivenessThroughOverlappingAccess is invoked.
@@ -296,10 +312,27 @@ class CanonicalizeOSSALifetime {
   CanonicalOSSAConsumeInfo consumes;
 
 public:
-  CanonicalizeOSSALifetime(bool pruneDebugMode, bool poisonRefsMode,
-                           NonLocalAccessBlockAnalysis *accessBlockAnalysis,
-                           DominanceInfo *domTree, InstructionDeleter &deleter)
+  void maybeNotifyMoveOnlyCopy(Operand *use) {
+    if (!moveOnlyCopyValueNotification)
+      return;
+    moveOnlyCopyValueNotification(use);
+  }
+
+  void maybeNotifyFinalConsumingUse(Operand *use) {
+    if (!moveOnlyFinalConsumingUse)
+      return;
+    moveOnlyFinalConsumingUse(use);
+  }
+
+  CanonicalizeOSSALifetime(
+      bool pruneDebugMode, bool poisonRefsMode,
+      NonLocalAccessBlockAnalysis *accessBlockAnalysis, DominanceInfo *domTree,
+      InstructionDeleter &deleter,
+      std::function<void(Operand *)> moveOnlyCopyValueNotification = nullptr,
+      std::function<void(Operand *)> moveOnlyFinalConsumingUse = nullptr)
       : pruneDebugMode(pruneDebugMode), poisonRefsMode(poisonRefsMode),
+        moveOnlyCopyValueNotification(moveOnlyCopyValueNotification),
+        moveOnlyFinalConsumingUse(moveOnlyFinalConsumingUse),
         accessBlockAnalysis(accessBlockAnalysis), domTree(domTree),
         deleter(deleter) {}
 

lib/SILGen/SILGenDecl.cpp

@@ -18,16 +18,18 @@
 #include "Scope.h"
 #include "SwitchEnumBuilder.h"
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
-#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/PropertyWrappers.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDebuggerClient.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILType.h"
 #include "swift/SIL/TypeLowering.h"
 #include "llvm/ADT/SmallString.h"
@@ -36,6 +38,13 @@
 using namespace swift;
 using namespace Lowering;
 
+// Utility for emitting diagnostics.
+template <typename... T, typename... U>
+static void diagnose(ASTContext &Context, SourceLoc loc, Diag<T...> diag,
+                     U &&...args) {
+  Context.Diags.diagnose(loc, diag, std::forward<U>(args)...);
+}
+
 void Initialization::_anchor() {}
 void SILDebuggerClient::anchor() {}
 
@@ -254,10 +263,6 @@ class DestroyLocalVariable : public Cleanup {
 
   void emit(SILGenFunction &SGF, CleanupLocation l,
             ForUnwind_t forUnwind) override {
-    SILValue val = SGF.VarLocs[Var].value;
-    if (SGF.getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
-        val->getOwnershipKind() != OwnershipKind::None)
-      SGF.B.createEndBorrow(l, val);
     SGF.destroyLocalVariable(l, Var);
   }
 
@@ -456,7 +461,16 @@ class LetValueInitialization : public Initialization {
       needsTemporaryBuffer =
           lowering.isAddressOnly() && SGF.silConv.useLoweredAddresses();
     }
-   
+
+    // Make sure that we have a non-address only type when binding a
+    // @_noImplicitCopy let.
+    if (SGF.getASTContext().LangOpts.EnableExperimentalMoveOnly &&
+        lowering.isAddressOnly() &&
+        vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
+      auto d = diag::noimplicitcopy_used_on_generic_or_existential;
+      diagnose(SGF.getASTContext(), vd->getLoc(), d);
+    }
+
     if (needsTemporaryBuffer) {
       address = SGF.emitTemporaryAllocation(vd, lowering.getLoweredType());
       if (isUninitialized)
@@ -517,7 +531,7 @@ class LetValueInitialization : public Initialization {
                                             SplitCleanups);
   }
 
-  void bindValue(SILValue value, SILGenFunction &SGF) {
+  void bindValue(SILValue value, SILGenFunction &SGF, bool wasPlusOne) {
     assert(!SGF.VarLocs.count(vd) && "Already emitted this vardecl?");
     // If we're binding an address to this let value, then we can use it as an
     // address later.  This happens when binding an address only parameter to
@@ -527,9 +541,33 @@ class LetValueInitialization : public Initialization {
     SILLocation PrologueLoc(vd);
 
     if (SGF.getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
-        value->getOwnershipKind() != OwnershipKind::None)
-      value = SILValue(
-          SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true));
+        value->getOwnershipKind() != OwnershipKind::None) {
+      if (!SGF.getASTContext().LangOpts.EnableExperimentalMoveOnly) {
+        value = SILValue(
+            SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true));
+      } else {
+        // If we have an owned value that had a cleanup, then create a
+        // move_value that acts as a consuming use of the value. The reason why
+        // we want this is even if we are only performing a borrow for our
+        // lexical lifetime, we want to ensure that our defs see this
+        // initialization as consuming this value.
+        if (value->getOwnershipKind() == OwnershipKind::Owned) {
+          assert(wasPlusOne);
+          value = SILValue(SGF.B.createMoveValue(PrologueLoc, value));
+        }
+
+        if (vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
+          value = SILValue(SGF.B.createBeginBorrow(PrologueLoc, value,
+                                                   /*isLexical*/ true));
+          value = SGF.B.createCopyValue(PrologueLoc, value);
+          value = SGF.B.createMoveValue(PrologueLoc, value);
+        } else {
+          value = SILValue(
+              SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true));
+        }
+      }
+    }
+
     SGF.VarLocs[vd] = SILGenFunction::VarLoc::get(value);
 
     // Emit a debug_value[_addr] instruction to record the start of this value's
@@ -540,26 +578,27 @@ class LetValueInitialization : public Initialization {
     SILDebugVariable DbgVar(vd->isLet(), /*ArgNo=*/0);
     SGF.B.emitDebugDescription(PrologueLoc, value, DbgVar);
   }
-  
+
   void copyOrInitValueInto(SILGenFunction &SGF, SILLocation loc,
                            ManagedValue value, bool isInit) override {
     // If this let value has an address, we can handle it just like a single
     // buffer value.
-    if (hasAddress())
+    if (hasAddress()) {
       return SingleBufferInitialization::
         copyOrInitValueIntoSingleBuffer(SGF, loc, value, isInit, address);
-    
+    }
+
     // Otherwise, we bind the value.
     if (isInit) {
       // Disable the rvalue expression cleanup, since the let value
       // initialization has a cleanup that lives for the entire scope of the
       // let declaration.
-      bindValue(value.forward(SGF), SGF);
+      bindValue(value.forward(SGF), SGF, value.isPlusOne(SGF));
     } else {
       // Disable the expression cleanup of the copy, since the let value
       // initialization has a cleanup that lives for the entire scope of the
       // let declaration.
-      bindValue(value.copyUnmanaged(SGF, loc).forward(SGF), SGF);
+      bindValue(value.copyUnmanaged(SGF, loc).forward(SGF), SGF, true);
     }
   }
 
@@ -1715,16 +1754,38 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
   // For 'let' bindings, we emit a release_value or destroy_addr, depending on
   // whether we have an address or not.
   SILValue Val = loc.value;
-  if (!Val->getType().isAddress()) {
-    SILValue valueToBeDestroyed;
-    if (getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
-        Val->getOwnershipKind() != OwnershipKind::None) {
-      auto *inst = cast<BeginBorrowInst>(Val.getDefiningInstruction());
-      valueToBeDestroyed = inst->getOperand();
-    } else {
-      valueToBeDestroyed = Val;
-    }
-    B.emitDestroyValueOperation(silLoc, valueToBeDestroyed);
-  } else
+
+  if (Val->getType().isAddress()) {
     B.createDestroyAddr(silLoc, Val);
+    return;
+  }
+
+  if (!getASTContext().SILOpts.EnableExperimentalLexicalLifetimes ||
+      Val->getOwnershipKind() == OwnershipKind::None) {
+    B.emitDestroyValueOperation(silLoc, Val);
+    return;
+  }
+
+  if (auto *bbi = dyn_cast<BeginBorrowInst>(Val.getDefiningInstruction())) {
+    B.createEndBorrow(silLoc, bbi);
+    B.emitDestroyValueOperation(silLoc, bbi->getOperand());
+    return;
+  }
+
+  if (getASTContext().LangOpts.EnableExperimentalMoveOnly) {
+    if (auto *mvi = dyn_cast<MoveValueInst>(Val.getDefiningInstruction())) {
+      if (auto *cvi = dyn_cast<CopyValueInst>(mvi->getOperand())) {
+        if (auto *bbi = dyn_cast<BeginBorrowInst>(cvi->getOperand())) {
+          if (bbi->isLexical()) {
+            B.emitDestroyValueOperation(silLoc, mvi);
+            B.createEndBorrow(silLoc, bbi);
+            B.emitDestroyValueOperation(silLoc, bbi->getOperand());
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  llvm_unreachable("unhandled case");
 }

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -17,6 +17,7 @@ target_sources(swiftSILOptimizer PRIVATE
   IRGenPrepare.cpp
   LowerHopToActor.cpp
   MandatoryInlining.cpp
+  MoveOnlyChecker.cpp
   NestedSemanticFunctionCheck.cpp
   OptimizeHopToExecutor.cpp
   PredictableMemOpt.cpp