Applied formatting

Author: nickolas-pohilets

CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift

@@ -124,7 +124,7 @@ public let COMMON_NODES: [Node] = [
       ),
     ]
   ),
-  
+
   // deinit-effect-specifiers -> async?
   Node(
     kind: .deinitEffectSpecifiers,

Sources/SwiftParser/Declarations.swift

@@ -1120,14 +1120,14 @@ extension Parser {
     _ handle: RecoveryConsumptionHandle
   ) -> RawDeinitializerDeclSyntax {
     let (unexpectedBeforeDeinitKeyword, deinitKeyword) = self.eat(handle)
-    
+
     var unexpectedNameAndSignature: [RawSyntax?] = []
     var unexpectedAfterAsync: [RawSyntax?] = []
 
     // 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)
@@ -1151,7 +1151,7 @@ extension Parser {
       }
       unexpectedAfterAsync.append(contentsOf: sig.unexpectedBetweenEffectSpecifiersAndOutput?.elements ?? [])
       if let output = sig.output {
-          unexpectedAfterAsync.append(RawSyntax(output))
+        unexpectedAfterAsync.append(RawSyntax(output))
       }
     }
     let items = self.parseOptionalCodeBlock()

Sources/SwiftParser/Specifiers.swift

@@ -418,7 +418,7 @@ extension RawAccessorEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
 }
 
 extension RawDeinitEffectSpecifiersSyntax {
-  enum MisspelledAsyncSpecifiers: TokenSpecSet {
+  enum MisspelledAsyncTokenKinds: TokenSpecSet {
     case await
     case reasync
 
@@ -437,33 +437,33 @@ extension RawDeinitEffectSpecifiersSyntax {
       }
     }
   }
-  
+
   enum MisspelledThrowsTokenKinds: TokenSpecSet {
-    case `try`
-    case `throw`
     case `rethrows`
+    case `throw`
     case `throws`
+    case `try`
 
     init?(lexeme: Lexer.Lexeme) {
       switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(.try, allowAtStartOfLine: false): self = .try
-      case TokenSpec(.throw, allowAtStartOfLine: false): self = .throw
       case TokenSpec(.rethrows): self = .rethrows
+      case TokenSpec(.throw, allowAtStartOfLine: false): self = .throw
       case TokenSpec(.throws): self = .throws
+      case TokenSpec(.try, allowAtStartOfLine: false): self = .try
       default: return nil
       }
     }
 
     var spec: TokenSpec {
       switch self {
-      case .try: return TokenSpec(.try, allowAtStartOfLine: false)
-      case .throw: return TokenSpec(.throw, allowAtStartOfLine: false)
       case .rethrows: return .keyword(.rethrows)
+      case .throw: return TokenSpec(.throw, allowAtStartOfLine: false)
       case .throws: return .keyword(.throws)
+      case .try: return TokenSpec(.try, allowAtStartOfLine: false)
       }
     }
   }
-  
+
   public init(
     _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil,
     asyncSpecifier: RawTokenSyntax?,
@@ -477,7 +477,7 @@ extension RawDeinitEffectSpecifiersSyntax {
       var unexpectedBeforeAsync: [RawSyntax?] = []
       var asyncKeyword: RawTokenSyntax? = asyncSpecifier?.raw.as(RawTokenSyntax.self)
       var unexpectedAfterAsync: [RawSyntax?] = []
-      
+
       unexpectedBeforeAsync.append(contentsOf: unexpectedBeforeAsyncSpecifier?.elements ?? [])
       unexpectedBeforeAsync.append(contentsOf: unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.elements ?? [])
       if let throwsKeyword = throwsSpecifier, !throwsKeyword.isMissing {
@@ -520,7 +520,7 @@ extension RawDeinitEffectSpecifiersSyntax {
           unexpectedAfterAsync = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier
         }
       }
-      
+
       self.init(
         unexpectedBeforeAsyncSpecifier,
         asyncSpecifier: asyncSpecifier,
@@ -633,19 +633,19 @@ extension Parser {
   mutating func parseAccessorEffectSpecifiers() -> RawAccessorEffectSpecifiersSyntax? {
     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 true {
       var progressed: Bool = false
-      
+
       if let realAsync = self.consume(if: .keyword(.async)) {
         progressed = true
         if asyncKeyword?.isMissing ?? true {
@@ -654,8 +654,8 @@ extension Parser {
           unexpectedAfterAsync.append(realAsync.raw)
         }
       }
-      
-      while let badAsync = self.consume(ifAnyIn: RawDeinitEffectSpecifiersSyntax.MisspelledAsyncSpecifiers.self) {
+
+      while let badAsync = self.consume(ifAnyIn: RawDeinitEffectSpecifiersSyntax.MisspelledAsyncTokenKinds.self) {
         progressed = true
         if asyncKeyword?.isMissing ?? true {
           unexpectedBeforeAsync.append(badAsync.raw)
@@ -668,7 +668,7 @@ extension Parser {
           asyncKeyword = missingToken(.keyword(.async))
         }
       }
-      
+
       while let badThrows = self.consume(ifAnyIn: RawDeinitEffectSpecifiersSyntax.MisspelledThrowsTokenKinds.self) {
         progressed = true
         if asyncKeyword?.isMissing ?? true {
@@ -677,10 +677,10 @@ extension Parser {
           unexpectedAfterAsync.append(badThrows.raw)
         }
       }
-      
+
       if !progressed { break }
     }
-    
+
     if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedAfterAsync.isEmpty {
       return nil
     }

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -797,10 +797,10 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
         handledNodes: [params.id]
       )
     }
-    
+
     return .visitChildren
   }
-  
+
   public override func visit(_ node: DeinitEffectSpecifiersSyntax) -> SyntaxVisitorContinueKind {
     let throwsTokens: [TokenKind] = [
       .keyword(.throws),
@@ -814,19 +814,20 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       if throwsTokens.contains(token.tokenKind) { return token }
       return nil
     }
-    
-    let unexpectedThrows = (node.unexpectedBeforeAsyncSpecifier?.compactMap(asThrowingToken) ?? []) + (node.unexpectedAfterAsyncSpecifier?.compactMap(asThrowingToken) ?? [])
+
+    let unexpectedThrows =
+      (node.unexpectedBeforeAsyncSpecifier?.compactMap(asThrowingToken) ?? []) + (node.unexpectedAfterAsyncSpecifier?.compactMap(asThrowingToken) ?? [])
     if let throwsKeyword = unexpectedThrows.first {
-        addDiagnostic(
-            throwsKeyword,
-            .deinitCannotThrow,
-            fixIts: [
-                FixIt(message: RemoveNodesFixIt(unexpectedThrows), changes: .makeMissing(unexpectedThrows))
-            ],
-            handledNodes: unexpectedThrows.map(\.id)
-        )
+      addDiagnostic(
+        throwsKeyword,
+        .deinitCannotThrow,
+        fixIts: [
+          FixIt(message: RemoveNodesFixIt(unexpectedThrows), changes: .makeMissing(unexpectedThrows))
+        ],
+        handledNodes: unexpectedThrows.map(\.id)
+      )
     }
-    
+
     let isOfSameKind = { AsyncEffectSpecifier(token: $0) != nil }
     if let asyncSpecifier = node.asyncSpecifier {
       let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedAfterAsyncSpecifier]
@@ -840,7 +841,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
           removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) }
         )
       }
-      
+
       if asyncSpecifier.isPresent {
         for case .some(let unexpected) in unexpectedNodes {
           for duplicateSpecifier in unexpected.presentTokens(satisfying: isOfSameKind) {
@@ -855,7 +856,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
         }
       }
     }
-    
+
     return .visitChildren
   }
 

Tests/SwiftParserTest/translated/AsyncTests.swift

@@ -149,7 +149,7 @@ final class AsyncTests: XCTestCase {
       }
       """,
       diagnostics: [
-        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code 'async' in subscript"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code 'async' in subscript")
       ]
     )
   }