Merge pull request #1656 from nickolas-pohilets/mpokhylets/async-deinit

Support for isolated and async deinit

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift

@@ -125,6 +125,21 @@ public let COMMON_NODES: [Node] = [
     ]
   ),
 
+  // deinit-effect-specifiers -> async?
+  Node(
+    kind: .deinitEffectSpecifiers,
+    base: .syntax,
+    nameForDiagnostics: "effect specifiers",
+    traits: [],
+    children: [
+      Child(
+        name: "AsyncSpecifier",
+        kind: .token(choices: [.keyword(text: "async")]),
+        isOptional: true
+      )
+    ]
+  ),
+
   Node(
     kind: .decl,
     base: .syntax,

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -584,6 +584,11 @@ public let DECL_NODES: [Node] = [
         kind: .token(choices: [.keyword(text: "deinit")]),
         documentation: "The deinit keyword."
       ),
+      Child(
+        name: "EffectSpecifiers",
+        kind: .node(kind: .deinitEffectSpecifiers),
+        isOptional: true
+      ),
       Child(
         name: "Body",
         kind: .node(kind: .codeBlock),

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -96,6 +96,7 @@ public enum SyntaxNodeKind: String, CaseIterable {
   case declName
   case decl
   case deferStmt
+  case deinitEffectSpecifiers
   case deinitializerDecl
   case derivativeRegistrationAttributeArguments
   case designatedTypeElement

Sources/SwiftParser/Declarations.swift

@@ -1045,18 +1045,45 @@ extension Parser {
     _ handle: RecoveryConsumptionHandle
   ) -> RawDeinitializerDeclSyntax {
     let (unexpectedBeforeDeinitKeyword, deinitKeyword) = self.eat(handle)
+
     var unexpectedNameAndSignature: [RawSyntax?] = []
-    unexpectedNameAndSignature.append(self.consume(if: TokenSpec(.identifier, allowAtStartOfLine: false)).map(RawSyntax.init))
-    if self.at(TokenSpec(.leftParen, allowAtStartOfLine: false)) {
-      unexpectedNameAndSignature.append(RawSyntax(parseFunctionSignature()))
+
+    // async is a contextual keyword
+    // must be parsed before attempting to parse identifier
+    var effectSpecifiers = parseDeinitEffectSpecifiers()
+
+    if effectSpecifiers == nil {
+      if let identifier = self.consume(if: TokenSpec(.identifier, allowAtStartOfLine: false)).map(RawSyntax.init) {
+        unexpectedNameAndSignature.append(identifier)
+      }
+      effectSpecifiers = parseDeinitEffectSpecifiers()
+    }
+    if effectSpecifiers == nil && self.at(TokenSpec(.leftParen, allowAtStartOfLine: false)) {
+      let input = parseParameterClause(RawParameterClauseSyntax.self) { parser in
+        parser.parseFunctionParameter()
+      }
+      unexpectedNameAndSignature.append(RawSyntax(input))
+
+      effectSpecifiers = parseDeinitEffectSpecifiers()
     }
+
+    var unexpectedAfterAsync: [RawSyntax?] = []
+    /// Only allow recovery to the arrow with exprKeyword precedence so we only
+    /// skip over misplaced identifiers and don't e.g. recover to an arrow in a 'where' clause.
+    if self.canRecoverTo(TokenSpec(.arrow, recoveryPrecedence: .exprKeyword)) != nil {
+      let output = self.parseFunctionReturnClause(effectSpecifiers: &effectSpecifiers, allowNamedOpaqueResultType: true)
+      unexpectedAfterAsync.append(RawSyntax(output))
+    }
+
     let items = self.parseOptionalCodeBlock()
     return RawDeinitializerDeclSyntax(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,
       unexpectedBeforeDeinitKeyword,
       deinitKeyword: deinitKeyword,
       RawUnexpectedNodesSyntax(unexpectedNameAndSignature, arena: self.arena),
+      effectSpecifiers: effectSpecifiers,
+      RawUnexpectedNodesSyntax(unexpectedAfterAsync, arena: arena),
       body: items,
       arena: self.arena
     )
@@ -1065,7 +1092,9 @@ extension Parser {
 
 extension Parser {
   /// If a `throws` keyword appears right in front of the `arrow`, it is returned as `misplacedThrowsKeyword` so it can be synthesized in front of the arrow.
-  mutating func parseFunctionReturnClause(effectSpecifiers: inout (some RawEffectSpecifiersTrait)?, allowNamedOpaqueResultType: Bool) -> RawReturnClauseSyntax {
+  mutating func parseFunctionReturnClause(effectSpecifiers: inout (some RawMisplacedEffectSpecifiersTrait)?, allowNamedOpaqueResultType: Bool)
+    -> RawReturnClauseSyntax
+  {
     let (unexpectedBeforeArrow, arrow) = self.expect(.arrow)
     let unexpectedBeforeReturnType = self.parseMisplacedEffectSpecifiers(&effectSpecifiers)
     let result: RawTypeSyntax
@@ -1149,7 +1178,7 @@ extension Parser {
 
     /// Only allow recovery to the arrow with exprKeyword precedence so we only
     /// skip over misplaced identifiers and don't e.g. recover to an arrow in a 'where' clause.
-    if self.at(.arrow) || self.canRecoverTo(TokenSpec(.arrow, recoveryPrecedence: .exprKeyword)) != nil {
+    if self.canRecoverTo(TokenSpec(.arrow, recoveryPrecedence: .exprKeyword)) != nil {
       output = self.parseFunctionReturnClause(effectSpecifiers: &effectSpecifiers, allowNamedOpaqueResultType: true)
     } else {
       output = nil

Sources/SwiftParser/Recovery.swift

@@ -130,7 +130,10 @@ extension Parser.Lookahead {
     #endif
     let initialTokensConsumed = self.tokensConsumed
 
-    precondition(!specSet.allCases.isEmpty, "SpecSet must have at least one case")
+    if specSet.allCases.isEmpty {
+      return nil
+    }
+
     let recoveryPrecedence =
       overrideRecoveryPrecedence ?? specSet.allCases.map({
         return $0.spec.recoveryPrecedence

Sources/SwiftParser/Specifiers.swift

@@ -134,7 +134,7 @@ public enum EffectSpecifier: TokenSpecSet {
 
 /// Raw syntax nodes don't have traits (because usually we don't need them).
 /// Specify the effect specifiers trait manually as a one off.
-protocol RawEffectSpecifiersTrait {
+protocol RawMisplacedEffectSpecifiersTrait {
   /// The token kinds that should be consumed as misspelled `asyncSpecifier`.
   /// Should be a subset of ``AsyncEffectSpecifier``.
   associatedtype MisspelledAsyncTokenKinds: TokenSpecSet
@@ -151,10 +151,21 @@ protocol RawEffectSpecifiersTrait {
   /// Should be a subset of ``ThrowsEffectSpecifier``.
   associatedtype CorrectThrowsTokenKinds: TokenSpecSet
 
-  var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get }
   var asyncSpecifier: RawTokenSyntax? { get }
-  var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { get }
   var throwsSpecifier: RawTokenSyntax? { get }
+
+  init(
+    asyncSpecifier: RawTokenSyntax?,
+    throwsSpecifier: RawTokenSyntax?,
+    arena: __shared SyntaxArena
+  )
+
+  func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsKeyword: RawTokenSyntax?, arena: __shared SyntaxArena) -> Self
+}
+
+protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait {
+  var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get }
+  var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { get }
   var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? { get }
 
   init(
@@ -168,6 +179,21 @@ protocol RawEffectSpecifiersTrait {
 }
 
 extension RawEffectSpecifiersTrait {
+  init(
+    asyncSpecifier: RawTokenSyntax?,
+    throwsSpecifier: RawTokenSyntax?,
+    arena: __shared SyntaxArena
+  ) {
+    self.init(
+      nil,
+      asyncSpecifier: asyncSpecifier,
+      nil,
+      throwsSpecifier: throwsSpecifier,
+      nil,
+      arena: arena
+    )
+  }
+
   func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsKeyword: RawTokenSyntax?, arena: __shared SyntaxArena) -> Self {
     return Self.init(
       self.unexpectedBeforeAsyncSpecifier,
@@ -415,7 +441,122 @@ extension RawAccessorEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
       }
     }
   }
+}
+
+extension RawDeinitEffectSpecifiersSyntax: RawMisplacedEffectSpecifiersTrait {
+  enum MisspelledAsyncTokenKinds: TokenSpecSet {
+    case await
+    case reasync
+
+    init?(lexeme: Lexer.Lexeme) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.await, allowAtStartOfLine: false): self = .await
+      case TokenSpec(.reasync): self = .reasync
+      default: return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case .await: return TokenSpec(.await, allowAtStartOfLine: false)
+      case .reasync: return .keyword(.reasync)
+      }
+    }
+  }
+
+  enum CorrectAsyncTokenKinds: TokenSpecSet {
+    case async
+
+    init?(lexeme: Lexer.Lexeme) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.async): self = .async
+      default: return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case .async: return .keyword(.async)
+      }
+    }
+  }
+
+  enum MisspelledThrowsTokenKinds: TokenSpecSet {
+    case `rethrows`
+    case `try`
+    case `throw`
+    case `throws`
 
+    init?(lexeme: Lexer.Lexeme) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.rethrows): self = .rethrows
+      case TokenSpec(.try, allowAtStartOfLine: false): self = .try
+      case TokenSpec(.throw, allowAtStartOfLine: false): self = .throw
+      case TokenSpec(.throws): self = .throws
+      default: return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case .rethrows: return .keyword(.rethrows)
+      case .try: return TokenSpec(.try, allowAtStartOfLine: false)
+      case .throw: return TokenSpec(.throw, allowAtStartOfLine: false)
+      case .throws: return .keyword(.throws)
+      }
+    }
+  }
+
+  enum CorrectThrowsTokenKinds: TokenSpecSet {
+    // Uninhabited
+
+    init?(lexeme: Lexer.Lexeme) {
+      return nil
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      }
+    }
+  }
+
+  var throwsSpecifier: RawTokenSyntax? { nil }
+
+  init(
+    asyncSpecifier: RawTokenSyntax?,
+    throwsSpecifier: RawTokenSyntax?,
+    arena: __shared SwiftSyntax.SyntaxArena
+  ) {
+    // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens
+    // and `CorrectThrowsTokenKinds` is an empty `TokenSpecSet`.
+    //
+    // We don't want to insert missing `throws` for deinit case,
+    // so if `parseMisplacedEffectSpecifiers()` creates one it will be discarded here.
+    precondition(throwsSpecifier?.isMissing ?? true)
+    self.init(
+      nil,
+      asyncSpecifier: asyncSpecifier,
+      nil,
+      arena: arena
+    )
+  }
+
+  func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsKeyword: RawTokenSyntax?, arena: SyntaxArena)
+    -> RawDeinitEffectSpecifiersSyntax
+  {
+    // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens
+    // and `CorrectThrowsTokenKinds` is an empty `TokenSpecSet`.
+    //
+    // We don't want to insert missing `throws` for deinit case,
+    // so if `parseMisplacedEffectSpecifiers()` creates one it will be discarded here.
+    precondition(throwsSpecifier?.isMissing ?? true)
+    return Self.init(
+      self.unexpectedBeforeAsyncSpecifier,
+      asyncSpecifier: self.asyncSpecifier ?? misplacedAsyncKeyword,
+      self.unexpectedAfterAsyncSpecifier,
+      arena: arena
+    )
+  }
 }
 
 extension TokenConsumer {
@@ -521,11 +662,57 @@ extension Parser {
     return parseEffectSpecifiers(RawAccessorEffectSpecifiersSyntax.self)
   }
 
+  mutating func parseDeinitEffectSpecifiers() -> RawDeinitEffectSpecifiersSyntax? {
+    // Note that parseEffectSpecifiers() consumes deinit name as unexpected token
+    // But we want it to be handled on the higher level.
+    // So we parseEffectSpecifiers() is not reused here.
+
+    var unexpectedBeforeAsync: [RawSyntax?] = []
+    var asyncKeyword: RawTokenSyntax?
+    var unexpectedAfterAsync: [RawSyntax?] = []
+
+    while let (specifier, handle) = self.at(anyIn: EffectSpecifiers.self) {
+      let beforeAsync = asyncKeyword?.isMissing ?? true
+      switch specifier {
+      case .async:
+        if beforeAsync {
+          asyncKeyword = self.eat(handle)
+        } else {
+          unexpectedAfterAsync.append(RawSyntax(self.eat(handle)))
+        }
+      case .await, .reasync:
+        if beforeAsync {
+          // Let's synthesize a missing 'async'. If we find a real async specifier
+          // later, we will replace the missing token by the present token.
+          asyncKeyword = missingToken(.async)
+        }
+        fallthrough
+      default:
+        if beforeAsync {
+          unexpectedBeforeAsync.append(RawSyntax(self.eat(handle)))
+        } else {
+          unexpectedAfterAsync.append(RawSyntax(self.eat(handle)))
+        }
+      }
+    }
+
+    if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedAfterAsync.isEmpty {
+      return nil
+    }
+
+    return RawDeinitEffectSpecifiersSyntax(
+      RawUnexpectedNodesSyntax(unexpectedBeforeAsync, arena: self.arena),
+      asyncSpecifier: asyncKeyword,
+      RawUnexpectedNodesSyntax(unexpectedAfterAsync, arena: self.arena),
+      arena: self.arena
+    )
+  }
+
   /// Consume any misplaced effect specifiers and return them in as unexpected tokens.
   /// When a misplaced effect specifier is consumed and `effectSpecifiers`
   /// doesn't have  an effect specifier of that kind, modify `effectSpecifiers`
   /// to have a missing specifier of that kind.
-  mutating func parseMisplacedEffectSpecifiers<S: RawEffectSpecifiersTrait>(_ effectSpecifiers: inout S?) -> RawUnexpectedNodesSyntax? {
+  mutating func parseMisplacedEffectSpecifiers<S: RawMisplacedEffectSpecifiersTrait>(_ effectSpecifiers: inout S?) -> RawUnexpectedNodesSyntax? {
     var synthesizedAsync: RawTokenSyntax? = nil
     var synthesizedThrows: RawTokenSyntax? = nil
     var unexpected: [RawTokenSyntax] = []
@@ -560,11 +747,8 @@ extension Parser {
         effectSpecifiers = specifiers.withMisplaced(async: synthesizedAsync, throws: synthesizedThrows, arena: self.arena)
       } else {
         effectSpecifiers = S(
-          nil,
           asyncSpecifier: synthesizedAsync,
-          nil,
           throwsSpecifier: synthesizedThrows,
-          nil,
           arena: self.arena
         )
       }