WIP: Don't store throwsSpecifier

Author: nickolas-pohilets

CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift

@@ -132,20 +132,13 @@ public let COMMON_NODES: [Node] = [
     name: "DeinitEffectSpecifiers",
     nameForDiagnostics: "effect specifiers",
     kind: "Syntax",
-    traits: [
-      "EffectSpecifiers"
-    ],
+    traits: [],
     children: [
       Child(
         name: "AsyncSpecifier",
         kind: .token(choices: [.keyword(text: "async")]),
         isOptional: true
-      ),
-      Child(
-        name: "ThrowsSpecifier",
-        kind: .token(choices: []),
-        isOptional: true
-      ),
+      )
     ]
   ),
 

Sources/SwiftParser/Specifiers.swift

@@ -488,7 +488,6 @@ extension RawDeinitEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
     }
   }
 
-  /*
   public init(
       _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil,
       asyncSpecifier: RawTokenSyntax?,
@@ -497,16 +496,22 @@ extension RawDeinitEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
       _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? = nil,
       arena: __shared SyntaxArena
     ) {
-      assert(throwsSpecifier == nil)
       let unexpectedAfterAsync: RawUnexpectedNodesSyntax?
-      if let afterThrows = unexpectedAfterThrowsSpecifier {
-        if let beforeThrows = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier {
-          unexpectedAfterAsync = RawUnexpectedNodesSyntax(beforeThrows.elements + afterThrows.elements, arena: arena)
+      if let throwsSpecifier = throwsSpecifier, throwsSpecifier.presence == .present {
+        var unexpected: [RawSyntax] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.elements ?? []
+        unexpected.append(throwsSpecifier.raw)
+        unexpected.append(contentsOf: unexpectedAfterThrowsSpecifier?.elements ?? [])
+        unexpectedAfterAsync = RawUnexpectedNodesSyntax(unexpected, arena: arena)
+      } else {
+        if let afterThrows = unexpectedAfterThrowsSpecifier {
+          if let beforeThrows = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier {
+            unexpectedAfterAsync = RawUnexpectedNodesSyntax(beforeThrows.elements + afterThrows.elements, arena: arena)
+          } else {
+            unexpectedAfterAsync = afterThrows
+          }
         } else {
-          unexpectedAfterAsync = afterThrows
+          unexpectedAfterAsync = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier
         }
-      } else {
-        unexpectedAfterAsync = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier
       }
       self.init(
         unexpectedBeforeAsyncSpecifier,
@@ -519,7 +524,6 @@ extension RawDeinitEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
   var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: SwiftSyntax.RawUnexpectedNodesSyntax? { unexpectedAfterAsyncSpecifier }
   var throwsSpecifier: SwiftSyntax.RawTokenSyntax? { nil }
   var unexpectedAfterThrowsSpecifier: SwiftSyntax.RawUnexpectedNodesSyntax? { nil }
-   */
 }
 
 extension TokenConsumer {

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -144,7 +144,6 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     unexpected: UnexpectedNodesSyntax?,
     unexpectedTokenCondition: (TokenSyntax) -> Bool,
     correctTokens: [TokenSyntax?],
-    correctTokenPossible: Bool = true,
     message: (_ misplacedTokens: [TokenSyntax]) -> some DiagnosticMessage,
     moveFixIt: (_ misplacedTokens: [TokenSyntax]) -> FixItMessage,
     removeRedundantFixIt: (_ misplacedTokens: [TokenSyntax]) -> FixItMessage? = { _ in nil }
@@ -182,7 +181,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     if changes.count > 1 {
       // Only emit a Fix-It if we are moving a token, i.e. also making a token present.
       fixIts.append(FixIt(message: moveFixIt(misplacedTokens), changes: changes))
-    } else if !correctTokens.isEmpty || !correctTokenPossible, let removeFixIt = removeRedundantFixIt(misplacedTokens) {
+    } else if !correctTokens.isEmpty, let removeFixIt = removeRedundantFixIt(misplacedTokens) {
       fixIts.append(FixIt(message: removeFixIt, changes: changes))
     }
 
@@ -232,27 +231,23 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
   }
 
   private func handleEffectSpecifiers(
-    _ node: some EffectSpecifiersSyntax,
-    asyncIsPossible: Bool = true,
-    misspelledAsync: StaticParserError = .misspelledAsync,
-    throwsIsPossible: Bool = true,
-    misspelledThrows: StaticParserError = .misspelledThrows
+    _ node: some EffectSpecifiersSyntax
   ) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren
     }
 
     let specifierInfo = [
-      (node.asyncSpecifier, { AsyncEffectSpecifier(token: $0) != nil }, asyncIsPossible, misspelledAsync),
-      (node.throwsSpecifier, { ThrowsEffectSpecifier(token: $0) != nil }, throwsIsPossible, misspelledThrows),
+      (node.asyncSpecifier, { AsyncEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledAsync),
+      (node.throwsSpecifier, { ThrowsEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledThrows),
     ]
 
     let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedAfterThrowsSpecifier]
 
     // Diagnostics that are emitted later silence previous diagnostics, so check
     // for the most contextual (and thus helpful) diagnostics last.
 
-    for (specifier, isOfSameKind, isPossible, misspelledError) in specifierInfo {
+    for (specifier, isOfSameKind, misspelledError) in specifierInfo {
       guard let specifier = specifier else {
         continue
       }
@@ -261,7 +256,6 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
           unexpected: unexpected,
           unexpectedTokenCondition: isOfSameKind,
           correctTokens: [specifier],
-          correctTokenPossible: isPossible,
           message: { _ in misspelledError },
           moveFixIt: { ReplaceTokensFixIt(replaceTokens: $0, replacements: [specifier]) },
           removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) }
@@ -280,7 +274,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       )
     }
 
-    for (specifier, isOfSameKind, _, _) in specifierInfo {
+    for (specifier, isOfSameKind, _) in specifierInfo {
       guard let specifier = specifier else {
         continue
       }
@@ -760,7 +754,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     let isOfAsyncKind = { AsyncEffectSpecifier(token: $0) != nil }
     let isOfThrowsKind = { ThrowsEffectSpecifier(token: $0) != nil }
 
-    let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedAfterThrowsSpecifier]
+    let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedAfterAsyncSpecifier]
 
     // Diagnostics that are emitted later silence previous diagnostics, so check
     // for the most contextual (and thus helpful) diagnostics last.
@@ -801,7 +795,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
 
     if let throwsKw = unexpectedThrows.first {
       exchangeTokens(
-        unexpected: node.unexpectedAfterThrowsSpecifier,
+        unexpected: node.unexpectedAfterAsyncSpecifier,
         unexpectedTokenCondition: isOfAsyncKind,
         correctTokens: [node.asyncSpecifier],
         message: { AsyncMustPrecedeThrows(asyncKeywords: $0, throwsKeyword: throwsKw) },

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -859,12 +859,8 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBeforeAsyncSpecifier"
   case \DeinitEffectSpecifiersSyntax.asyncSpecifier:
     return "asyncSpecifier"
-  case \DeinitEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier:
-    return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier"
-  case \DeinitEffectSpecifiersSyntax.throwsSpecifier:
-    return "throwsSpecifier"
-  case \DeinitEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier:
-    return "unexpectedAfterThrowsSpecifier"
+  case \DeinitEffectSpecifiersSyntax.unexpectedAfterAsyncSpecifier:
+    return "unexpectedAfterAsyncSpecifier"
   case \DeinitializerDeclSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
   case \DeinitializerDeclSyntax.attributes:

Sources/SwiftSyntax/generated/SyntaxTraits.swift

@@ -493,8 +493,6 @@ extension DeclNameArgumentsSyntax: ParenthesizedSyntax {}
 
 extension DeferStmtSyntax: WithCodeBlockSyntax {}
 
-extension DeinitEffectSpecifiersSyntax: EffectSpecifiersSyntax {}
-
 extension DeinitializerDeclSyntax: AttributedSyntax {}
 
 extension DictionaryElementSyntax: WithTrailingCommaSyntax {}

Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift

@@ -6013,19 +6013,15 @@ public struct RawDeinitEffectSpecifiersSyntax: RawSyntaxNodeProtocol {
   public init(
       _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil, 
       asyncSpecifier: RawTokenSyntax?, 
-      _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, 
-      throwsSpecifier: RawTokenSyntax?, 
-      _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedAfterAsyncSpecifier: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .deinitEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in
+      kind: .deinitEffectSpecifiers, uninitializedCount: 3, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAsyncSpecifier?.raw
       layout[1] = asyncSpecifier?.raw
-      layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw
-      layout[3] = throwsSpecifier?.raw
-      layout[4] = unexpectedAfterThrowsSpecifier?.raw
+      layout[2] = unexpectedAfterAsyncSpecifier?.raw
     }
     self.init(unchecked: raw)
   }
@@ -6038,17 +6034,9 @@ public struct RawDeinitEffectSpecifiersSyntax: RawSyntaxNodeProtocol {
     layoutView.children[1].map(RawTokenSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterAsyncSpecifier: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  
-  public var throwsSpecifier: RawTokenSyntax? {
-    layoutView.children[3].map(RawTokenSyntax.init(raw:))
-  }
-  
-  public var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
 }
 
 @_spi(RawSyntax)

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -877,12 +877,10 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 3, verify(layout[3], as: RawCodeBlockSyntax.self))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .deinitEffectSpecifiers:
-    assert(layout.count == 5)
+    assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax?.self, tokenChoices: [.keyword("async")]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: []))
-    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .deinitializerDecl:
     assert(layout.count == 11)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift

@@ -5864,28 +5864,14 @@ public struct DeinitEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
       leadingTrivia: Trivia? = nil,
       _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil,
       asyncSpecifier: TokenSyntax? = nil,
-      _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil,
-      throwsSpecifier: TokenSyntax? = nil,
-      _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil,
+      _ unexpectedAfterAsyncSpecifier: UnexpectedNodesSyntax? = nil,
       trailingTrivia: Trivia? = nil
 
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
     // before they can be added as children of the new arena.
-    let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (
-            unexpectedBeforeAsyncSpecifier, 
-            asyncSpecifier, 
-            unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, 
-            throwsSpecifier, 
-            unexpectedAfterThrowsSpecifier
-          ))) {(arena, _) in
-      let layout: [RawSyntax?] = [
-          unexpectedBeforeAsyncSpecifier?.raw, 
-          asyncSpecifier?.raw, 
-          unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, 
-          throwsSpecifier?.raw, 
-          unexpectedAfterThrowsSpecifier?.raw
-        ]
+    let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAsyncSpecifier, asyncSpecifier, unexpectedAfterAsyncSpecifier))) {(arena, _) in
+      let layout: [RawSyntax?] = [unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedAfterAsyncSpecifier?.raw]
       let raw = RawSyntax.makeLayout(
         kind: SyntaxKind.deinitEffectSpecifiers,
         from: layout,
@@ -5917,7 +5903,7 @@ public struct DeinitEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
 
-  public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? {
+  public var unexpectedAfterAsyncSpecifier: UnexpectedNodesSyntax? {
     get {
       return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
     }
@@ -5926,32 +5912,8 @@ public struct DeinitEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable {
     }
   }
 
-  public var throwsSpecifier: TokenSyntax? {
-    get {
-      return data.child(at: 3, parent: Syntax(self)).map(TokenSyntax.init)
-    }
-    set(value) {
-      self = DeinitEffectSpecifiersSyntax(data.replacingChild(at: 3, with: value?.raw, arena: SyntaxArena()))
-    }
-  }
-  
-  public var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? {
-    get {
-      return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
-    }
-    set(value) {
-      self = DeinitEffectSpecifiersSyntax(data.replacingChild(at: 4, with: value?.raw, arena: SyntaxArena()))
-    }
-  }
-  
   public static var structure: SyntaxNodeStructure {
-    return .layout([
-          \Self.unexpectedBeforeAsyncSpecifier, 
-          \Self.asyncSpecifier, 
-          \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, 
-          \Self.throwsSpecifier, 
-          \Self.unexpectedAfterThrowsSpecifier
-        ])
+    return .layout([\Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, \Self.unexpectedAfterAsyncSpecifier])
   }
 }
 

Tests/SwiftParserTest/translated/AsyncTests.swift

@@ -150,21 +150,7 @@ final class AsyncTests: XCTestCase {
       """,
       diagnostics: [
         DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code 'async' in subscript"),
-      ],
-      fixedSource: """
-        class X {
-          init() async { }
-          deinit async { }
-          func f() async { }
-          subscript(x: Int) async -> Int {
-            get {
-              return 0
-            }
-            set async {
-            }
-          }
-        }
-        """
+      ]
     )
   }