Merge pull request #63922 from kavon/standard-issue-neuralyzer

Implement the `forget` statement (as `_forget`)

Author: kavon

include/swift/AST/DiagnosticsParse.def

@@ -1071,6 +1071,10 @@ 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", ())
+
 // Await/Async
 ERROR(expected_await_not_async,none,
       "found 'async' in expression; did you mean 'await'?", ())

include/swift/AST/DiagnosticsSema.def

@@ -493,6 +493,10 @@ 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",
+      (Type,Type))
+
 ERROR(cannot_convert_closure_result,none,
       "cannot convert value of type %0 to closure result type %1",
       (Type,Type))
@@ -4497,6 +4501,27 @@ ERROR(opaque_type_var_no_underlying_type,none,
       "property declares an opaque return type, but cannot infer the "
       "underlying type from its initializer expression", ())
 
+ERROR(forget_wrong_context_decl,none,
+      "'forget' statement cannot appear in %0",
+      (DescriptiveDeclKind))
+ERROR(forget_wrong_context_closure,none,
+      "'forget' statement cannot appear in closure",
+      ())
+ERROR(forget_wrong_context_misc,none,
+      "'forget' statement cannot appear in this context",
+      ())
+ERROR(forget_wrong_context_copyable,none,
+      "'forget' statement can only appear in noncopyable type's member",
+      (DescriptiveDeclKind))
+ERROR(forget_wrong_context_nonconsuming,none,
+      "'forget' 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",
+      (Type))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Patterns
 //------------------------------------------------------------------------------

include/swift/AST/NameLookup.h

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

include/swift/AST/Stmt.h

@@ -38,6 +38,7 @@ class DeclContext;
 class Evaluator;
 class Expr;
 class FuncDecl;
+class AbstractFunctionDecl;
 class Pattern;
 class PatternBindingDecl;
 class VarDecl;
@@ -1482,6 +1483,44 @@ class ThrowStmt : public Stmt {
   }
 };
 
+/// ForgetStmt - 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 {
+  Expr *SubExpr;
+  SourceLoc ForgetLoc;
+  AbstractFunctionDecl *InnermostMethod;
+
+public:
+  explicit ForgetStmt(SourceLoc forgetLoc, Expr *subExpr)
+      : Stmt(StmtKind::Forget, /*Implicit=*/false),
+        SubExpr(subExpr), ForgetLoc(forgetLoc), InnermostMethod(nullptr) {}
+
+  SourceLoc getForgetLoc() const { return ForgetLoc; }
+
+  SourceLoc getStartLoc() const { return ForgetLoc; }
+  SourceLoc getEndLoc() const;
+  SourceRange getSourceRange() const {
+    return SourceRange(ForgetLoc, getEndLoc());
+  }
+
+  Expr *getSubExpr() const { return SubExpr; }
+  void setSubExpr(Expr *subExpr) { SubExpr = subExpr; }
+
+  /// Retrieves the saved innermost method / accessor decl in which this Stmt
+  /// resides. Corresponds to \c DeclContext::getInnermostMethodContext.
+  /// Must be saved with \c setInnermostMethodContext during typechecking.
+  AbstractFunctionDecl *getInnermostMethodContext() { return InnermostMethod; }
+  void setInnermostMethodContext(AbstractFunctionDecl *afd) {
+    assert(afd); // shouldn't be clearing this
+    InnermostMethod = afd;
+  }
+
+  static bool classof(const Stmt *S) {
+    return S->getKind() == StmtKind::Forget;
+  }
+};
+
 /// PoundAssertStmt - Asserts that a condition is true, at compile time.
 class PoundAssertStmt : public Stmt {
   SourceRange Range;

include/swift/AST/StmtNodes.def

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

include/swift/Parse/Parser.h

@@ -615,6 +615,24 @@ class Parser {
             isa<AccessorDecl>(CurDeclContext) &&
             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
+  /// 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
+  /// a nice diagnostic.
+  bool isContextualForgetKeyword() {
+    // must be `forget` ...
+    if (!Tok.isContextualKeyword("_forget"))
+      return false;
+
+    // followed by either an identifier, `self`, or `Self`.
+    return peekToken().isAny(tok::identifier, tok::kw_self, tok::kw_Self);
+  }
 
   /// Read tokens until we get to one of the specified tokens, then
   /// return without consuming it.  Because we cannot guarantee that the token
@@ -1848,6 +1866,7 @@ class Parser {
   ParserResult<Stmt> parseStmtReturn(SourceLoc tryLoc);
   ParserResult<Stmt> parseStmtYield(SourceLoc tryLoc);
   ParserResult<Stmt> parseStmtThrow(SourceLoc tryLoc);
+  ParserResult<Stmt> parseStmtForget();
   ParserResult<Stmt> parseStmtDefer();
   ParserStatus
   parseStmtConditionElement(SmallVectorImpl<StmtConditionElement> &result,

include/swift/Sema/ConstraintLocator.h

@@ -53,6 +53,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_EnumCaseRawValue, ///< Raw value specified for "case X = 42" in enum.
   CTP_DefaultParameter, ///< Default value in parameter 'foo(a : Int = 42)'.
 

lib/AST/ASTDumper.cpp

@@ -1803,6 +1803,12 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitForgetStmt(ForgetStmt *S) {
+    printCommon(S, "forget_stmt") << '\n';
+    printRec(S->getSubExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitPoundAssertStmt(PoundAssertStmt *S) {
     printCommon(S, "pound_assert");
     OS << " message=" << QuotedString(S->getMessage()) << "\n";

lib/AST/ASTPrinter.cpp

@@ -5176,6 +5176,11 @@ void PrintAST::visitThrowStmt(ThrowStmt *stmt) {
   visit(stmt->getSubExpr());
 }
 
+void PrintAST::visitForgetStmt(ForgetStmt *stmt) {
+  Printer << "_forget" << " ";
+  visit(stmt->getSubExpr());
+}
+
 void PrintAST::visitPoundAssertStmt(PoundAssertStmt *stmt) {
   Printer << tok::pound_assert << " ";
   // FIXME: print expression.

lib/AST/ASTScopeCreation.cpp

@@ -489,6 +489,12 @@ class NodeAdder
     return p;
   }
 
+  ASTScopeImpl *visitForgetStmt(ForgetStmt *fs, ASTScopeImpl *p,
+                               ScopeCreator &scopeCreator) {
+    visitExpr(fs->getSubExpr(), p, scopeCreator);
+    return p;
+  }
+
   ASTScopeImpl *visitPoundAssertStmt(PoundAssertStmt *pas,
                                      ASTScopeImpl *p,
                                      ScopeCreator &scopeCreator) {