ensure forget cannot appear outside the type's module

We can't implement `forget` unless if we know all of the fields
in the type, so it cannot be resilient at all. We go further and
say that you can only `forget` from the same module, since that's
what the proposal currently states. If needed we can loosen that
in the future.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -4518,7 +4518,9 @@ ERROR(forget_wrong_context_nonconsuming,none,
       (DescriptiveDeclKind))
 ERROR(forget_wrong_not_self,none,
       "you can only forget 'self'", ())
-
+ERROR(forget_wrong_module,none,
+      "can only 'forget' from the same module defining type %0",
+      (Type))
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Patterns

lib/Sema/TypeCheckStmt.cpp

@@ -1256,14 +1256,33 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     if (!diagnosed) {
       Type nominalType =
           fn->getDeclContext()->getSelfNominalTypeDecl()->getDeclaredType();
-      if (nominalType->isPureMoveOnly()) {
-        // Set the contextual type for the sub-expression before we typecheck.
-        contextualInfo = {nominalType, CTP_ForgetStmt};
-      } else {
+      if (!nominalType->isPureMoveOnly()) {
         ctx.Diags.diagnose(FS->getForgetLoc(),
                            diag::forget_wrong_context_copyable,
                            fn->getDescriptiveKind());
         diagnosed = true;
+      } else {
+        // Set the contextual type for the sub-expression before we typecheck.
+        contextualInfo = {nominalType, CTP_ForgetStmt};
+
+        // Now verify that we're not forgetting a type from another module.
+        //
+        // NOTE: We could do a proper resilience check instead of just asking
+        // if the modules differ, so that you can forget a @frozen type from a
+        // resilient module. But for now the proposal simply says that it has to
+        // be the same module, which is probably better for everyone.
+        auto *typeDecl = nominalType->getAnyNominal();
+        auto *fnModule = fn->getModuleContext();
+        auto *typeModule = typeDecl->getModuleContext();
+        if (fnModule != typeModule) {
+          ctx.Diags.diagnose(FS->getForgetLoc(), diag::forget_wrong_module,
+                             nominalType);
+          diagnosed = true;
+        } else {
+          assert(
+              !typeDecl->isResilient(fnModule, ResilienceExpansion::Maximal) &&
+              "trying to forget a type resilient to us!");
+        }
       }
     }
 

test/Sema/Inputs/forget_module_adjacent.swift

@@ -0,0 +1,11 @@
+public extension Regular {
+  __consuming func shutdownParty() {
+    _forget self // ok; same module
+  }
+}
+
+public extension Frozen {
+  __consuming func shutdownParty() {
+    _forget self // ok; same module
+  }
+}

test/Sema/Inputs/forget_module_defining.swift

@@ -0,0 +1,22 @@
+@_moveOnly
+public struct Regular {
+  private let sorry = 0
+}
+
+@_moveOnly
+@frozen public struct Frozen {
+  private let lotfan = 0
+}
+
+
+public extension Regular {
+  __consuming func endParty() {
+    _forget self
+  }
+}
+
+public extension Frozen {
+  __consuming func endParty() {
+    _forget self
+  }
+}

test/Sema/forget_module.swift

@@ -0,0 +1,24 @@
+// RUN: %empty-directory(%t)
+
+// >> first try when no library evolution is specified
+// RUN: %target-swift-frontend -enable-experimental-move-only -emit-module -o %t/SorryModule.swiftmodule %S/Inputs/forget_module_defining.swift %S/Inputs/forget_module_adjacent.swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-move-only -I %t
+
+// >> now again with library evolution; we expect the same result.
+// RUN: %target-swift-frontend -enable-library-evolution -enable-experimental-move-only -emit-module -o %t/SorryModule.swiftmodule %S/Inputs/forget_module_defining.swift %S/Inputs/forget_module_adjacent.swift
+// RUN: %target-typecheck-verify-swift -enable-experimental-move-only -I %t
+
+// "Sorry" is meaningless
+import SorryModule
+
+extension Regular {
+  __consuming func delete() {
+    _forget self // expected-error {{can only 'forget' from the same module defining type 'Regular'}}
+  }
+}
+
+extension Frozen {
+  __consuming func delete() {
+    _forget self // expected-error {{can only 'forget' from the same module defining type 'Frozen'}}
+  }
+}