implement parsing of forget statement

Currently staged in as `_forget` until we're ready to greenlight it.

The parsing uses one-token lookahead to disambiguate when someone
writes `forget(self)` to mean a function call, from `forget self`
to mean the actual forget statement.

More tests will be in the swift compiler repository.

Author: kavon

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -133,6 +133,7 @@ public let KEYWORDS: [KeywordSpec] = [
   KeywordSpec("fileprivate", isLexerClassified: true, requiresTrailingSpace: true),
   KeywordSpec("final"),
   KeywordSpec("for", isLexerClassified: true, requiresTrailingSpace: true),
+  KeywordSpec("_forget"),
   KeywordSpec("forward"),
   KeywordSpec("func", isLexerClassified: true, requiresTrailingSpace: true),
   KeywordSpec("get"),

CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift.gyb

@@ -4,7 +4,7 @@
   # -*- mode: Swift -*-
   # Ignore the following admonition it applies to the resulting .swift file only
 }%
-//// Automatically Generated From GenericNodes.swift.gyb.
+//// Automatically Generated From StmtNodes.swift.gyb.
 //// Do Not Edit Directly!
 //===----------------------------------------------------------------------===//
 //

CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift

@@ -1,4 +1,4 @@
-//// Automatically Generated From GenericNodes.swift.gyb.
+//// Automatically Generated From StmtNodes.swift.gyb.
 //// Do Not Edit Directly!
 //===----------------------------------------------------------------------===//
 //
@@ -211,6 +211,16 @@ public let STMT_NODES: [Node] = [
                nameForDiagnostics: "body")
        ]),
 
+  Node(name: "ForgetStmt",
+       nameForDiagnostics: "'forget' statement",
+       kind: "Stmt",
+       children: [
+         Child(name: "ForgetKeyword",
+               kind: .token(choices: [.keyword(text: "_forget")])),
+         Child(name: "Expression",
+               kind: .node(kind: "Expr"))
+       ]),
+
   Node(name: "GuardStmt",
        nameForDiagnostics: "'guard' statement",
        kind: "Stmt",

Sources/SwiftParser/Statements.swift

@@ -55,6 +55,7 @@ extension Parser {
   ///     statement → control-transfer-statement ';'?
   ///     statement → defer-statement ';'?
   ///     statement → do-statement ';'?
+  ///     statement → forget-statement ';'?
   ///
   ///     loop-statement → for-in-statement
   ///     loop-statement → while-statement
@@ -123,6 +124,8 @@ extension Parser {
       return label(self.parseContinueStatement(continueHandle: handle), with: optLabel)
     case (.fallthroughKeyword, let handle)?:
       return label(self.parseFallthroughStatement(fallthroughHandle: handle), with: optLabel)
+    case (.forgetKeyword, let handle)?:
+      return label(self.parseForgetStatement(forgetHandle: handle), with: optLabel)
     case (.returnKeyword, let handle)?:
       return label(self.parseReturnStatement(returnHandle: handle), with: optLabel)
     case (.throwKeyword, let handle)?:
@@ -374,6 +377,28 @@ extension Parser {
   }
 }
 
+// MARK: Forget Statements
+
+extension Parser {
+  /// Parse a forget statement.
+  ///
+  /// Grammar
+  /// =======
+  ///
+  ///     forget-statement → 'forget' expression
+  @_spi(RawSyntax)
+  public mutating func parseForgetStatement(forgetHandle: RecoveryConsumptionHandle) -> RawForgetStmtSyntax {
+    let (unexpectedBeforeForgetKeyword, forgetKeyword) = self.eat(forgetHandle)
+    let expr = self.parseExpression()
+    return RawForgetStmtSyntax(
+      unexpectedBeforeForgetKeyword,
+      forgetKeyword: forgetKeyword,
+      expression: expr,
+      arena: self.arena
+    )
+  }
+}
+
 // MARK: Defer Statements
 
 extension Parser {
@@ -946,6 +971,19 @@ extension Parser.Lookahead {
         // yield statement of some singular expression.
         return !self.peek().isAtStartOfLine
       }
+    case .forgetKeyword?:
+      switch peek().rawTokenKind {
+      case .identifier, .keyword:
+        // Since some identifiers like "self" are classified as keywords,
+        // we want to recognize those too, to handle "forget self". We also
+        // accept any identifier since we want to emit a nice error message
+        // later on during type checking.
+        return true
+      default:
+        // any other token following "forget" means it's not the statement.
+        // For example, could be the function call "forget()".
+        return false
+      }
     case nil:
       return false
     }

Sources/SwiftParser/TokenSpecSet.swift

@@ -80,6 +80,7 @@ enum CanBeStatementStart: TokenSpecSet {
   case doKeyword
   case fallthroughKeyword
   case forKeyword
+  case forgetKeyword
   case guardKeyword
   case ifKeyword
   case repeatKeyword
@@ -97,6 +98,7 @@ enum CanBeStatementStart: TokenSpecSet {
     case TokenSpec(.do): self = .doKeyword
     case TokenSpec(.fallthrough): self = .fallthroughKeyword
     case TokenSpec(.for): self = .forKeyword
+    case TokenSpec(._forget): self = .forgetKeyword
     case TokenSpec(.guard): self = .guardKeyword
     case TokenSpec(.if): self = .ifKeyword
     case TokenSpec(.repeat): self = .repeatKeyword
@@ -117,6 +119,7 @@ enum CanBeStatementStart: TokenSpecSet {
     case .doKeyword: return .keyword(.do)
     case .fallthroughKeyword: return .keyword(.fallthrough)
     case .forKeyword: return .keyword(.for)
+    case .forgetKeyword: return TokenSpec(._forget, recoveryPrecedence: .stmtKeyword)
     case .guardKeyword: return .keyword(.guard)
     case .ifKeyword: return .keyword(.if)
     case .repeatKeyword: return .keyword(.repeat)

Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md

@@ -97,6 +97,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/FallthroughStmtSyntax>
 - <doc:SwiftSyntax/BreakStmtSyntax>
 - <doc:SwiftSyntax/ThrowStmtSyntax>
+- <doc:SwiftSyntax/ForgetStmtSyntax>
 
 ### Expressions
 

Sources/SwiftSyntax/generated/Keyword.swift

@@ -117,6 +117,7 @@ public enum Keyword: UInt8, Hashable {
   case `fileprivate`
   case final
   case `for`
+  case _forget
   case forward
   case `func`
   case get
@@ -428,6 +429,8 @@ public enum Keyword: UInt8, Hashable {
         self = .`default`
       case "dynamic":
         self = .dynamic
+      case "_forget":
+        self = ._forget
       case "forward":
         self = .forward
       case "message":
@@ -946,6 +949,7 @@ public enum Keyword: UInt8, Hashable {
       "fileprivate", 
       "final", 
       "for", 
+      "_forget", 
       "forward", 
       "func", 
       "get", 

Sources/SwiftSyntax/generated/Misc.swift

@@ -120,6 +120,7 @@ extension Syntax {
           .node(FloatLiteralExprSyntax.self), 
           .node(ForInStmtSyntax.self), 
           .node(ForcedValueExprSyntax.self), 
+          .node(ForgetStmtSyntax.self), 
           .node(FunctionCallExprSyntax.self), 
           .node(FunctionDeclSyntax.self), 
           .node(FunctionParameterListSyntax.self), 
@@ -493,6 +494,8 @@ extension SyntaxKind {
       return ForInStmtSyntax.self
     case .forcedValueExpr:
       return ForcedValueExprSyntax.self
+    case .forgetStmt:
+      return ForgetStmtSyntax.self
     case .functionCallExpr:
       return FunctionCallExprSyntax.self
     case .functionDecl:
@@ -1020,6 +1023,8 @@ extension SyntaxKind {
       return "'for' statement"
     case .forcedValueExpr:
       return "force unwrap"
+    case .forgetStmt:
+      return "'forget' statement"
     case .functionCallExpr:
       return "function call"
     case .functionDecl:

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -885,6 +885,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: ForgetStmtSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+  
+  override open func visitPost(_ node: ForgetStmtSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  
   override open func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -522,7 +522,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
 
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
+    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .forgetStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -535,7 +535,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   internal init(_ data: SyntaxData) {
     #if DEBUG
     switch data.raw.kind {
-    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
+    case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .forgetStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt:
       break
     default:
       fatalError("Unable to create StmtSyntax from \(data.raw.kind)")
@@ -578,6 +578,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
           .node(ExpressionStmtSyntax.self), 
           .node(FallthroughStmtSyntax.self), 
           .node(ForInStmtSyntax.self), 
+          .node(ForgetStmtSyntax.self), 
           .node(GuardStmtSyntax.self), 
           .node(LabeledStmtSyntax.self), 
           .node(MissingStmtSyntax.self), 

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -120,6 +120,7 @@ public enum SyntaxEnum {
   case floatLiteralExpr(FloatLiteralExprSyntax)
   case forInStmt(ForInStmtSyntax)
   case forcedValueExpr(ForcedValueExprSyntax)
+  case forgetStmt(ForgetStmtSyntax)
   case functionCallExpr(FunctionCallExprSyntax)
   case functionDecl(FunctionDeclSyntax)
   case functionParameterList(FunctionParameterListSyntax)
@@ -492,6 +493,8 @@ public extension Syntax {
       return .forInStmt(ForInStmtSyntax(self)!)
     case .forcedValueExpr:
       return .forcedValueExpr(ForcedValueExprSyntax(self)!)
+    case .forgetStmt:
+      return .forgetStmt(ForgetStmtSyntax(self)!)
     case .functionCallExpr:
       return .functionCallExpr(FunctionCallExprSyntax(self)!)
     case .functionDecl:

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -120,6 +120,7 @@ public enum SyntaxKind {
   case floatLiteralExpr
   case forInStmt
   case forcedValueExpr
+  case forgetStmt
   case functionCallExpr
   case functionDecl
   case functionParameterList

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -753,6 +753,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `ForgetStmtSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ForgetStmtSyntax) -> StmtSyntax {
+    return StmtSyntax(visitChildren(node))
+  }
+  
   /// Visit a `FunctionCallExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3375,6 +3382,20 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplForgetStmtSyntax(_ data: SyntaxData) -> Syntax {
+    let node = ForgetStmtSyntax(data)
+    // Accessing _syntaxNode directly is faster than calling Syntax(node)
+    visitPre(node._syntaxNode)
+    defer { 
+      visitPost(node._syntaxNode) 
+    }
+    if let newNode = visitAny(node._syntaxNode) { 
+      return newNode 
+    }
+    return Syntax(visit(node))
+  }
+  
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplFunctionCallExprSyntax(_ data: SyntaxData) -> Syntax {
     let node = FunctionCallExprSyntax(data)
@@ -5809,6 +5830,8 @@ open class SyntaxRewriter {
       return visitImplForInStmtSyntax
     case .forcedValueExpr:
       return visitImplForcedValueExprSyntax
+    case .forgetStmt:
+      return visitImplForgetStmtSyntax
     case .functionCallExpr:
       return visitImplFunctionCallExprSyntax
     case .functionDecl:
@@ -6339,6 +6362,8 @@ open class SyntaxRewriter {
       return visitImplForInStmtSyntax(data)
     case .forcedValueExpr:
       return visitImplForcedValueExprSyntax(data)
+    case .forgetStmt:
+      return visitImplForgetStmtSyntax(data)
     case .functionCallExpr:
       return visitImplFunctionCallExprSyntax(data)
     case .functionDecl:

Sources/SwiftSyntax/generated/SyntaxTransform.swift

@@ -539,6 +539,11 @@ public protocol SyntaxTransformVisitor {
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: ForcedValueExprSyntax) -> ResultType
 
+  /// Visiting `ForgetStmtSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: the sum of whatever the child visitors return.
+  func visit(_ node: ForgetStmtSyntax) -> ResultType
+  
   /// Visiting `FunctionCallExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -2053,6 +2058,13 @@ extension SyntaxTransformVisitor {
     visitAny(Syntax(node))
   }
 
+  /// Visiting `ForgetStmtSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: nil by default.
+  public func visit(_ node: ForgetStmtSyntax) -> ResultType {
+    visitAny(Syntax(node))
+  }
+  
   /// Visiting `FunctionCallExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -3357,6 +3369,8 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .forcedValueExpr(let derived):
       return visit(derived)
+    case .forgetStmt(let derived):
+      return visit(derived)
     case .functionCallExpr(let derived):
       return visit(derived)
     case .functionDecl(let derived):

Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -1282,6 +1282,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: ForcedValueExprSyntax) {
   }
 
+  /// Visiting `ForgetStmtSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: ForgetStmtSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+  
+  /// The function called after visiting `ForgetStmtSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: ForgetStmtSyntax) {
+  }
+  
   /// Visiting `FunctionCallExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4310,6 +4322,17 @@ open class SyntaxVisitor {
     visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplForgetStmtSyntax(_ data: SyntaxData) {
+    let node = ForgetStmtSyntax(data)
+    let needsChildren = (visit(node) == .visitChildren)
+    // Avoid calling into visitChildren if possible.
+    if needsChildren && !node.raw.layoutView!.children.isEmpty {
+      visitChildren(node)
+    }
+    visitPost(node)
+  }
+  
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplFunctionCallExprSyntax(_ data: SyntaxData) {
     let node = FunctionCallExprSyntax(data)
@@ -6241,6 +6264,8 @@ open class SyntaxVisitor {
       visitImplForInStmtSyntax(data)
     case .forcedValueExpr:
       visitImplForcedValueExprSyntax(data)
+    case .forgetStmt:
+      visitImplForgetStmtSyntax(data)
     case .functionCallExpr:
       visitImplFunctionCallExprSyntax(data)
     case .functionDecl: