[move-only] Mark self of move only struct/enum types in deinits as being move-only.

This ensures that if we try to escape self or assign it to a variable, we
error since at the end of the deinit we always consume self and clean up its
variables.

I did not handle unique classes since it would have required a bit more surgery
around how deinits are handled and we do not need unique classes for our MVP.

rdar://102339259

Author: gottesmm

lib/SILGen/SILGenDestructor.cpp

@@ -37,7 +37,7 @@ void SILGenFunction::emitDestroyingDestructor(DestructorDecl *dd) {
 
   auto cd = cast<ClassDecl>(dd->getDeclContext()->getSelfNominalTypeDecl());
   auto &C = cd->getASTContext();
-  SILValue selfValue = emitSelfDecl(dd->getImplicitSelfDecl());
+  SILValue selfValue = emitSelfDeclForDestructor(dd->getImplicitSelfDecl());
 
   // Create a basic block to jump to for the implicit destruction behavior
   // of releasing the elements and calling the superclass destructor.
@@ -179,7 +179,8 @@ void SILGenFunction::emitDeallocatingClassDestructor(DestructorDecl *dd) {
   loc.markAutoGenerated();
 
   // Emit the prolog.
-  SILValue initialSelfValue = emitSelfDecl(dd->getImplicitSelfDecl());
+  SILValue initialSelfValue =
+      emitSelfDeclForDestructor(dd->getImplicitSelfDecl());
 
   // Form a reference to the destroying destructor.
   SILDeclRef dtorConstant(dd, SILDeclRef::Kind::Destroyer);
@@ -233,7 +234,7 @@ void SILGenFunction::emitDeallocatingMoveOnlyDestructor(DestructorDecl *dd) {
     loc.markAutoGenerated();
 
   // Emit the prolog.
-  auto selfValue = emitSelfDecl(dd->getImplicitSelfDecl());
+  auto selfValue = emitSelfDeclForDestructor(dd->getImplicitSelfDecl());
 
   // Create a basic block to jump to for the implicit destruction behavior
   // of releasing the elements and calling the superclass destructor.
@@ -264,7 +265,7 @@ void SILGenFunction::emitIVarDestroyer(SILDeclRef ivarDestroyer) {
   loc.markAutoGenerated();
 
   ManagedValue selfValue = ManagedValue::forUnmanaged(
-      emitSelfDecl(cd->getDestructor()->getImplicitSelfDecl()));
+      emitSelfDeclForDestructor(cd->getDestructor()->getImplicitSelfDecl()));
 
   auto cleanupLoc = CleanupLocation(loc);
   prepareEpilog(None, false, cleanupLoc);
@@ -593,7 +594,7 @@ void SILGenFunction::emitObjCDestructor(SILDeclRef dtor) {
   if (dd->isImplicit())
     loc.markAutoGenerated();
 
-  SILValue selfValue = emitSelfDecl(dd->getImplicitSelfDecl());
+  SILValue selfValue = emitSelfDeclForDestructor(dd->getImplicitSelfDecl());
 
   // Create a basic block to jump to for the implicit destruction behavior
   // of releasing the elements and calling the superclass destructor.

lib/SILGen/SILGenFunction.h

@@ -1054,7 +1054,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   /// emitSelfDecl - Emit a SILArgument for 'self', register it in varlocs, set
   /// up debug info, etc.  This returns the 'self' value.
-  SILValue emitSelfDecl(VarDecl *selfDecl);
+  ///
+  /// This is intended to only be used for destructors.
+  SILValue emitSelfDeclForDestructor(VarDecl *selfDecl);
 
   /// Emits a temporary allocation that will be deallocated automatically at the
   /// end of the current scope. Returns the address of the allocation.

lib/SILGen/SILGenProlog.cpp

@@ -34,10 +34,25 @@ static void diagnose(ASTContext &Context, SourceLoc loc, Diag<T...> diag,
   Context.Diags.diagnose(loc, diag, std::forward<U>(args)...);
 }
 
-SILValue SILGenFunction::emitSelfDecl(VarDecl *selfDecl) {
+SILValue SILGenFunction::emitSelfDeclForDestructor(VarDecl *selfDecl) {
   // Emit the implicit 'self' argument.
   SILType selfType = getLoweredLoadableType(selfDecl->getType());
   SILValue selfValue = F.begin()->createFunctionArgument(selfType, selfDecl);
+
+  // If we have a move only type, then mark it with mark_must_check so we can't
+  // escape it.
+  if (selfType.isMoveOnly()) {
+    // For now, we do not handle move only class deinits. This is because we
+    // need to do a bit more refactoring to handle the weird way that it deals
+    // with ownership. But for simple move only deinits (like struct/enum), that
+    // are owned, lets mark them as needing to be no implicit copy checked so
+    // they cannot escape.
+    if (selfValue->getOwnershipKind() == OwnershipKind::Owned) {
+      selfValue = B.createMarkMustCheckInst(
+          selfDecl, selfValue, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+    }
+  }
+
   VarLocs[selfDecl] = VarLoc::get(selfValue);
   SILLocation PrologueLoc(selfDecl);
   PrologueLoc.markAsPrologue();

test/SILOptimizer/moveonly_deinits.swift

@@ -0,0 +1,39 @@
+// RUN: %target-swift-frontend -enable-experimental-move-only -verify -emit-sil %s
+
+class Klass {}
+
+var globalMoveOnlyStruct = MoveOnlyStruct()
+var globalMoveOnlyEnum = MoveOnlyEnum.lhs(Klass())
+
+@_moveOnly
+struct MoveOnlyStruct {
+    var k = Klass()
+
+    deinit { // expected-error {{'self' consumed more than once}}
+        let x = self // expected-note {{consuming use}}
+        _ = x
+        var y = MoveOnlyStruct()
+        y = self // expected-note {{consuming use}}
+        // We get an infinite recursion since we are going to call our own
+        // deinit here. We are just testing diagnostics here though.
+        _ = y // expected-warning {{function call causes an infinite recursion}}
+        globalMoveOnlyStruct = self // expected-note {{consuming use}}
+    } // expected-note {{consuming use}}
+}
+
+@_moveOnly
+enum MoveOnlyEnum {
+    case lhs(Klass)
+    case rhs(Klass)
+
+    deinit { // expected-error {{'self' consumed more than once}}
+        let x = self // expected-note {{consuming use}}
+        _ = x
+        var y = MoveOnlyEnum.lhs(Klass())
+        y = self // expected-note {{consuming use}}
+        // We get an infinite recursion since we are going to call our own
+        // deinit here. We are just testing diagnostics here though.
+        _ = y // expected-warning {{function call causes an infinite recursion}}
+        globalMoveOnlyEnum = self // expected-note {{consuming use}}
+    } // expected-note {{consuming use}}
+}