Merge pull request #65931 from kavon/discard-generics-v2

more `discard` fixes in Sema

Author: kavon

lib/Sema/TypeCheckStmt.cpp

@@ -1262,7 +1262,8 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     // check the kind of type this discard statement appears within.
     if (!diagnosed) {
       auto *nominalDecl = fn->getDeclContext()->getSelfNominalTypeDecl();
-      Type nominalType = nominalDecl->getDeclaredTypeInContext();
+      Type nominalType =
+          fn->mapTypeIntoContext(nominalDecl->getDeclaredInterfaceType());
 
       // must be noncopyable
       if (!nominalType->isPureMoveOnly()) {
@@ -1288,17 +1289,16 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
         // if the modules differ, so that you can discard 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();
+        auto *typeModule = nominalDecl->getModuleContext();
         if (fnModule != typeModule) {
           ctx.Diags.diagnose(DS->getDiscardLoc(), diag::discard_wrong_module,
                              nominalType);
           diagnosed = true;
         } else {
           assert(
-              !typeDecl->isResilient(fnModule, ResilienceExpansion::Maximal) &&
-              "trying to discard a type resilient to us!");
+              !nominalDecl->isResilient(fnModule, ResilienceExpansion::Maximal)
+                  && "trying to discard a type resilient to us!");
         }
       }
     }
@@ -1314,13 +1314,14 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     if (!diagnosed) {
       bool isSelf = false;
       auto *checkE = DS->getSubExpr();
+      assert(fn->getImplicitSelfDecl() && "no self?");
 
       // Look through a load. Only expected if we're in an init.
       if (auto *load = dyn_cast<LoadExpr>(checkE))
           checkE = load->getSubExpr();
 
       if (auto DRE = dyn_cast<DeclRefExpr>(checkE))
-        isSelf = DRE->getDecl()->getName().isSimpleName("self");
+        isSelf = DRE->getDecl() == fn->getImplicitSelfDecl();
 
       if (!isSelf) {
         ctx.Diags

test/Interpreter/moveonly_discard.swift

@@ -9,8 +9,7 @@ func print_closing_MFD() { print("closing MaybeFileDescriptor") }
 
 enum E: Error { case err }
 
-@_moveOnly
-struct FileDescriptor {
+struct FileDescriptor: ~Copyable {
   var fd: Int
   static var nextFD: Int = 0
 
@@ -59,7 +58,7 @@ struct FileDescriptor {
   }
 }
 
-@_moveOnly enum MaybeFileDescriptor {
+enum MaybeFileDescriptor: ~Copyable {
   case some(FileDescriptor)
   case nothing
 
@@ -83,6 +82,14 @@ struct FileDescriptor {
   }
 }
 
+struct SillyEmptyGeneric<T>: ~Copyable {
+  consuming func identity(_ t: T) -> T {
+    discard self
+    return t
+  }
+  deinit { fatalError("ran unexpectedly!") }
+}
+
 func main() {
   let _ = {
     let x = FileDescriptor() // 0
@@ -161,6 +168,13 @@ func main() {
     // CHECK: closing file descriptor: 13
   }()
 
+  let _ = {
+    let x = SillyEmptyGeneric<[Int]>()
+    let z = [1, 2]
+    let ans = x.identity(z)
+    assert(z == ans)
+  }()
+
 }
 
 main()

test/Sema/discard.swift

@@ -162,8 +162,33 @@ enum NoDeinitEnum: ~Copyable {
   }
 }
 
-struct HasGenericNotStored<T>: ~Copyable {
+struct HasGenericNotStored<T>: ~Copyable { // expected-note 2{{arguments to generic parameter 'T' ('Int' and 'T') are expected to be equal}}
   consuming func discard() { discard self }
+
+  consuming func bad_discard1() {
+    discard HasGenericNotStored<Int>()
+    // expected-error@-1 {{cannot convert value of type 'HasGenericNotStored<Int>' to expected discard type 'HasGenericNotStored<T>'}}
+    // expected-error@-2 {{you can only discard 'self'}}
+  }
+
+  consuming func bad_discard2() {
+    let `self` = HasGenericNotStored<Int>()
+    discard `self`
+    // expected-error@-1 {{cannot convert value of type 'HasGenericNotStored<Int>' to expected discard type 'HasGenericNotStored<T>'}}
+    // expected-error@-2 {{you can only discard 'self'}}{{13-19=self}}
+  }
+
   func identity(_ t: T) -> T { return t }
   deinit{}
 }
+
+struct Court: ~Copyable {
+  let x: Int
+
+  consuming func discard(_ other: consuming Court) {
+    let `self` = other
+    discard `self` // expected-error {{you can only discard 'self'}}{{13-19=self}}
+  }
+
+  deinit { print("deinit of \(self.x)") }
+}