Merge pull request #65787 from kavon/forget-to-discard

rename `_forget` to `discard`; deprecate `_forget`

Author: kavon

include/swift/AST/DiagnosticsParse.def

@@ -1092,9 +1092,13 @@ NOTE(indent_expression_to_silence,none,
 ERROR(expected_expr_throw,PointsToFirstBadToken,
       "expected expression in 'throw' statement", ())
 
-// Forget Statement
-ERROR(expected_expr_forget,PointsToFirstBadToken,
-      "expected expression in 'forget' statement", ())
+// Discard Statement
+ERROR(expected_expr_discard,PointsToFirstBadToken,
+      "expected expression in 'discard' statement", ())
+WARNING(forget_is_deprecated,PointsToFirstBadToken,
+      "'_forget' keyword is deprecated and will be removed soon; "
+      "use 'discard' instead",
+      ())
 
 // Await/Async
 ERROR(expected_await_not_async,none,

include/swift/AST/DiagnosticsSIL.def

@@ -735,15 +735,15 @@ 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", ())
 
-// forget statement
-ERROR(forget_nontrivial_storage,none,
-      "can only 'forget' type %0 if it contains trivially-destroyed "
+// discard statement
+ERROR(discard_nontrivial_storage,none,
+      "can only 'discard' type %0 if it contains trivially-destroyed "
       "stored properties at this time",
       (Type))
-NOTE(forget_nontrivial_storage_note,none,
+NOTE(discard_nontrivial_storage_note,none,
       "type %0 cannot be trivially destroyed",
       (Type))
-NOTE(forget_nontrivial_implicit_storage_note,none,
+NOTE(discard_nontrivial_implicit_storage_note,none,
      "type %0 implicitly contains %1 which cannot be trivially destroyed",
      (Type, Type))
 

include/swift/AST/DiagnosticsSema.def

@@ -493,8 +493,8 @@ ERROR(cannot_convert_yield_value_protocol,none,
 ERROR(cannot_convert_yield_value_nil,none,
       "nil is not compatible with expected yield type %0", (Type))
 
-ERROR(cannot_convert_forget_value,none,
-      "cannot convert value of type %0 to expected forget type %1",
+ERROR(cannot_convert_discard_value,none,
+      "cannot convert value of type %0 to expected discard type %1",
       (Type,Type))
 
 ERROR(cannot_convert_closure_result,none,
@@ -4609,30 +4609,30 @@ ERROR(opaque_type_var_no_underlying_type,none,
 
 
 //------------------------------------------------------------------------------
-// MARK: Forget Statement
+// MARK: Discard Statement
 //------------------------------------------------------------------------------
-ERROR(forget_wrong_context_decl,none,
-      "'forget' statement cannot appear in %0",
+ERROR(discard_wrong_context_decl,none,
+      "'discard' statement cannot appear in %0",
       (DescriptiveDeclKind))
-ERROR(forget_no_deinit,none,
-      "'forget' has no effect for type %0 unless it has a deinitializer",
+ERROR(discard_no_deinit,none,
+      "'discard' has no effect for type %0 unless it has a deinitializer",
       (Type))
-ERROR(forget_wrong_context_closure,none,
-      "'forget' statement cannot appear in closure",
+ERROR(discard_wrong_context_closure,none,
+      "'discard' statement cannot appear in closure",
       ())
-ERROR(forget_wrong_context_misc,none,
-      "'forget' statement cannot appear in this context",
+ERROR(discard_wrong_context_misc,none,
+      "'discard' statement cannot appear in this context",
       ())
-ERROR(forget_wrong_context_copyable,none,
-      "'forget' statement can only appear in noncopyable type's member",
+ERROR(discard_wrong_context_copyable,none,
+      "'discard' statement can only appear in noncopyable type's member",
       (DescriptiveDeclKind))
-ERROR(forget_wrong_context_nonconsuming,none,
-      "'forget' statement can only appear in consuming %0",
+ERROR(discard_wrong_context_nonconsuming,none,
+      "'discard' statement can only appear in consuming %0",
       (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",
+ERROR(discard_wrong_not_self,none,
+      "you can only discard 'self'", ())
+ERROR(discard_wrong_module,none,
+      "can only 'discard' from the same module defining type %0",
       (Type))
 
 //------------------------------------------------------------------------------

include/swift/AST/NameLookup.h

@@ -650,7 +650,7 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
   void visitReturnStmt(ReturnStmt *) {}
   void visitYieldStmt(YieldStmt *) {}
   void visitThrowStmt(ThrowStmt *) {}
-  void visitForgetStmt(ForgetStmt *) {}
+  void visitDiscardStmt(DiscardStmt *) {}
   void visitPoundAssertStmt(PoundAssertStmt *) {}
   void visitDeferStmt(DeferStmt *DS) {
     // Nothing in the defer is visible.

include/swift/AST/Stmt.h

@@ -1510,25 +1510,26 @@ class ThrowStmt : public Stmt {
   }
 };
 
-/// ForgetStmt - Consumes a noncopyable value and performs memberwise
+/// DiscardStmt - Consumes a noncopyable value and performs memberwise
 /// destruction of unconsumed fields, without invoking its deinit. Only
-/// supported form is "forget self".
-class ForgetStmt : public Stmt {
+/// supported form is "discard self".
+class DiscardStmt : public Stmt {
   Expr *SubExpr;
-  SourceLoc ForgetLoc;
+  SourceLoc DiscardLoc;
   AbstractFunctionDecl *InnermostMethod;
 
 public:
-  explicit ForgetStmt(SourceLoc forgetLoc, Expr *subExpr)
-      : Stmt(StmtKind::Forget, /*Implicit=*/false),
-        SubExpr(subExpr), ForgetLoc(forgetLoc), InnermostMethod(nullptr) {}
+  explicit DiscardStmt(SourceLoc discardLoc, Expr *subExpr)
+      : Stmt(StmtKind::Discard, /*Implicit=*/false),
+        SubExpr(subExpr), DiscardLoc(discardLoc), InnermostMethod(nullptr) {}
 
-  SourceLoc getForgetLoc() const { return ForgetLoc; }
+  /// Location of the 'discard' keyword.
+  SourceLoc getDiscardLoc() const { return DiscardLoc; }
 
-  SourceLoc getStartLoc() const { return ForgetLoc; }
+  SourceLoc getStartLoc() const { return DiscardLoc; }
   SourceLoc getEndLoc() const;
   SourceRange getSourceRange() const {
-    return SourceRange(ForgetLoc, getEndLoc());
+    return SourceRange(DiscardLoc, getEndLoc());
   }
 
   Expr *getSubExpr() const { return SubExpr; }
@@ -1544,7 +1545,7 @@ class ForgetStmt : public Stmt {
   }
 
   static bool classof(const Stmt *S) {
-    return S->getKind() == StmtKind::Forget;
+    return S->getKind() == StmtKind::Discard;
   }
 };
 

include/swift/AST/StmtNodes.def

@@ -66,7 +66,7 @@ STMT(Continue, Stmt)
 STMT(Fallthrough, Stmt)
 STMT(Fail, Stmt)
 STMT(Throw, Stmt)
-STMT(Forget, Stmt)
+STMT(Discard, Stmt)
 STMT(PoundAssert, Stmt)
 LAST_STMT(PoundAssert)
 

include/swift/Parse/Parser.h

@@ -600,18 +600,19 @@ class Parser {
             cast<AccessorDecl>(CurDeclContext)->isCoroutine());
   }
 
-  /// `forget self` is the only valid phrase, but we peek ahead for just any
-  /// identifier after `forget` to determine if it's the statement. This helps
-  /// us avoid interpreting `forget(self)` as the statement and not a call.
-  /// We also want to be mindful of statements like `forget ++ something` where
+  /// `discard self` is the only valid phrase, but we peek ahead for just any
+  /// identifier after `discard` to determine if it's the statement. This helps
+  /// us avoid interpreting `discard(self)` as the statement and not a call.
+  /// We also want to be mindful of statements like `discard ++ something` where
   /// folks have defined a custom operator returning void.
   ///
-  /// Later, type checking will verify that you're forgetting the right thing
-  /// so that when people make a mistake, thinking they can `forget x` we give
+  /// Later, type checking will verify that you're discarding the right thing
+  /// so that when people make a mistake, thinking they can `discard x` we give
   /// a nice diagnostic.
-  bool isContextualForgetKeyword() {
-    // must be `forget` ...
-    if (!Tok.isContextualKeyword("_forget"))
+  bool isContextualDiscardKeyword() {
+    // must be `discard` ...
+    if (!(Tok.isContextualKeyword("_forget") // NOTE: support for deprecated _forget
+        || Tok.isContextualKeyword("discard")))
       return false;
 
     // followed by either an identifier, `self`, or `Self`.
@@ -1860,7 +1861,7 @@ class Parser {
   ParserResult<Stmt> parseStmtReturn(SourceLoc tryLoc);
   ParserResult<Stmt> parseStmtYield(SourceLoc tryLoc);
   ParserResult<Stmt> parseStmtThrow(SourceLoc tryLoc);
-  ParserResult<Stmt> parseStmtForget();
+  ParserResult<Stmt> parseStmtDiscard();
   ParserResult<Stmt> parseStmtDefer();
   ParserStatus
   parseStmtConditionElement(SmallVectorImpl<StmtConditionElement> &result,

include/swift/Sema/ConstraintLocator.h

@@ -54,7 +54,7 @@ enum ContextualTypePurpose : uint8_t {
   CTP_YieldByValue,     ///< By-value yield operand.
   CTP_YieldByReference, ///< By-reference yield operand.
   CTP_ThrowStmt,        ///< Value specified to a 'throw' statement.
-  CTP_ForgetStmt,        ///< Value specified to a 'forget' statement.
+  CTP_DiscardStmt,      ///< Value specified to a 'discard' statement.
   CTP_EnumCaseRawValue, ///< Raw value specified for "case X = 42" in enum.
   CTP_DefaultParameter, ///< Default value in parameter 'foo(a : Int = 42)'.
 

lib/AST/ASTDumper.cpp

@@ -1804,8 +1804,8 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
-  void visitForgetStmt(ForgetStmt *S) {
-    printCommon(S, "forget_stmt") << '\n';
+  void visitDiscardStmt(DiscardStmt *S) {
+    printCommon(S, "discard_stmt") << '\n';
     printRec(S->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }

lib/AST/ASTPrinter.cpp

@@ -5403,8 +5403,8 @@ void PrintAST::visitThrowStmt(ThrowStmt *stmt) {
   visit(stmt->getSubExpr());
 }
 
-void PrintAST::visitForgetStmt(ForgetStmt *stmt) {
-  Printer << "_forget" << " ";
+void PrintAST::visitDiscardStmt(DiscardStmt *stmt) {
+  Printer << "discard" << " ";
   visit(stmt->getSubExpr());
 }