emit error if _forget is used on a type with no deinit

rdar://108877261

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -4599,9 +4599,16 @@ ERROR(opaque_type_var_no_underlying_type,none,
       "property declares an opaque return type, but cannot infer the "
       "underlying type from its initializer expression", ())
 
+
+//------------------------------------------------------------------------------
+// MARK: Forget Statement
+//------------------------------------------------------------------------------
 ERROR(forget_wrong_context_decl,none,
       "'forget' statement cannot appear in %0",
       (DescriptiveDeclKind))
+ERROR(forget_no_deinit,none,
+      "'forget' has no effect for type %0 unless it has a deinitializer",
+      (Type))
 ERROR(forget_wrong_context_closure,none,
       "'forget' statement cannot appear in closure",
       ())

lib/Sema/TypeCheckStmt.cpp

@@ -1259,15 +1259,25 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
       }
     }
 
-    // This member function/accessor/etc has to be within a noncopyable type.
+    // check the kind of type this forget statement appears within.
     if (!diagnosed) {
-      Type nominalType =
-          fn->getDeclContext()->getSelfNominalTypeDecl()->getDeclaredType();
+      auto *nominalDecl = fn->getDeclContext()->getSelfNominalTypeDecl();
+      Type nominalType = nominalDecl->getDeclaredType();
+
+      // must be noncopyable
       if (!nominalType->isPureMoveOnly()) {
         ctx.Diags.diagnose(FS->getForgetLoc(),
                            diag::forget_wrong_context_copyable,
                            fn->getDescriptiveKind());
         diagnosed = true;
+
+      // has to have a deinit or else it's pointless.
+      } else if (!nominalDecl->getValueTypeDestructor()) {
+        ctx.Diags.diagnose(FS->getForgetLoc(),
+                           diag::forget_no_deinit,
+                           nominalType)
+            .fixItRemove(FS->getSourceRange());
+        diagnosed = true;
       } else {
         // Set the contextual type for the sub-expression before we typecheck.
         contextualInfo = {nominalType, CTP_ForgetStmt};

test/SILGen/forget.swift

@@ -7,6 +7,8 @@ func invokedDeinit() {}
   case some(File)
   case none
 
+  deinit {}
+
   // NOTE: we can't pattern match on self since
   // that would consume it before we can forget self!
   var test: Int {

test/SILOptimizer/moveonly_forget.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -sil-verify-all -verify -emit-sil %s
+// RUN: %target-swift-frontend -sil-verify-all -verify -emit-sil -enable-experimental-feature MoveOnlyEnumDeinits %s
 
 func posix_close(_ t: Int) {}
 
@@ -29,6 +29,8 @@ struct GoodFileDescriptor {
 struct BadFileDescriptor {
   let _fd: Int = 0
 
+  deinit {}
+
   var rawFileDescriptor: Int {
     __consuming get { // expected-error {{'self' consumed more than once}}
       _forget self    // expected-note {{consuming use here}}
@@ -90,4 +92,6 @@ final class Wallet {
     }
   }
 
+  deinit {}
+
 }

test/Sema/Inputs/forget_module_adjacent.swift

@@ -1,6 +1,7 @@
 public extension Regular {
   __consuming func shutdownParty() {
-    _forget self // ok; same module
+    // FIXME: rdar://108933330 (cannot define struct deinit with -enable-library-evolution)
+//    _forget self // ok; same module
   }
 }
 

test/Sema/Inputs/forget_module_defining.swift

@@ -1,20 +1,23 @@
 @_moveOnly
 public struct Regular {
   private let sorry = 0
+  // FIXME: rdar://108933330 (cannot define struct deinit with -enable-library-evolution)
+//  deinit {}
 }
 
-@_moveOnly
-@frozen public struct Frozen {
-  private let lotfan = 0
-}
-
-
 public extension Regular {
   __consuming func endParty() {
-    _forget self
+    // FIXME: rdar://108933330 (cannot define struct deinit with -enable-library-evolution)
+//    _forget self
   }
 }
 
+@_moveOnly
+@frozen public struct Frozen {
+  private let lotfan = 0
+  deinit {}
+}
+
 public extension Frozen {
   __consuming func endParty() {
     _forget self

test/Sema/forget.swift

@@ -147,3 +147,17 @@ enum E: Error { case err }
     try? take().close()
   }
 }
+
+struct NoDeinitStruct: ~Copyable {
+  consuming func blah() {
+    _forget self // expected-error {{'forget' has no effect for type 'NoDeinitStruct' unless it has a deinitializer}}{{5-18=}}
+  }
+}
+
+enum NoDeinitEnum: ~Copyable {
+  case whatever
+
+  consuming func blah() {
+    _forget self // expected-error {{'forget' has no effect for type 'NoDeinitEnum' unless it has a deinitializer}}{{5-18=}}
+  }
+}

test/Sema/forget_module.swift

@@ -13,7 +13,8 @@ import SorryModule
 
 extension Regular {
   __consuming func delete() {
-    _forget self // expected-error {{can only 'forget' from the same module defining type 'Regular'}}
+    // FIXME: rdar://108933330 (cannot define struct deinit with -enable-library-evolution)
+//    _forget self // DISABLED-error {{can only 'forget' from the same module defining type 'Regular'}}
   }
 }
 

test/expr/print/forget.swift

@@ -5,6 +5,8 @@ struct S {
   __consuming func c() {
     _forget self
   }
+
+  deinit {}
 }
 
 // CHECK: @_moveOnly internal struct S {