Simplified logic for parsing deinit effect specifiers

Author: nickolas-pohilets

Sources/SwiftParser/Specifiers.swift

@@ -417,54 +417,6 @@ extension RawAccessorEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
   }
 }
 
-extension RawDeinitEffectSpecifiersSyntax {
-  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 MisspelledThrowsTokenKinds: TokenSpecSet {
-    case `rethrows`
-    case `throw`
-    case `throws`
-    case `try`
-
-    init?(lexeme: Lexer.Lexeme) {
-      switch PrepareForKeywordMatch(lexeme) {
-      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 .rethrows: return .keyword(.rethrows)
-      case .throw: return TokenSpec(.throw, allowAtStartOfLine: false)
-      case .throws: return .keyword(.throws)
-      case .try: return TokenSpec(.try, allowAtStartOfLine: false)
-      }
-    }
-  }
-}
-
 extension TokenConsumer {
   mutating func at<SpecSet1: TokenSpecSet, SpecSet2: TokenSpecSet>(
     anyIn specSet1: SpecSet1.Type,
@@ -576,45 +528,32 @@ extension Parser {
     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 {
-          asyncKeyword = realAsync
-        } else {
-          unexpectedAfterAsync.append(realAsync.raw)
-        }
-      }
-
-      while let badAsync = self.consume(ifAnyIn: RawDeinitEffectSpecifiersSyntax.MisspelledAsyncTokenKinds.self) {
-        progressed = true
-        if asyncKeyword?.isMissing ?? true {
-          unexpectedBeforeAsync.append(badAsync.raw)
+    
+    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(badAsync.raw)
+          unexpectedAfterAsync.append(RawSyntax(self.eat(handle)))
         }
-        if asyncKeyword == nil {
+      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(.keyword(.async))
+          asyncKeyword = missingToken(.async)
         }
-      }
-
-      while let badThrows = self.consume(ifAnyIn: RawDeinitEffectSpecifiersSyntax.MisspelledThrowsTokenKinds.self) {
-        progressed = true
-        if asyncKeyword?.isMissing ?? true {
-          unexpectedBeforeAsync.append(badThrows.raw)
+        fallthrough
+      default:
+        if beforeAsync {
+          unexpectedBeforeAsync.append(RawSyntax(self.eat(handle)))
         } else {
-          unexpectedAfterAsync.append(badThrows.raw)
+          unexpectedAfterAsync.append(RawSyntax(self.eat(handle)))
         }
       }
-
-      if !progressed { break }
     }
-
+    
     if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedAfterAsync.isEmpty {
       return nil
     }

Sources/SwiftParser/TokenSpecSet.swift

@@ -919,3 +919,38 @@ enum ExpressionStart: TokenSpecSet {
     }
   }
 }
+
+enum EffectSpecifiers: TokenSpecSet {
+  case async
+  case await
+  case reasync
+  case `rethrows`
+  case `throw`
+  case `throws`
+  case `try`
+
+  init?(lexeme: Lexer.Lexeme) {
+    switch PrepareForKeywordMatch(lexeme) {
+    case TokenSpec(.async): self = .async
+    case TokenSpec(.await, allowAtStartOfLine: false): self = .await
+    case TokenSpec(.reasync): self = .reasync
+    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 .async: return .keyword(.async)
+    case .await: return TokenSpec(.await, allowAtStartOfLine: false)
+    case .reasync: return .keyword(.reasync)
+    case .rethrows: return .keyword(.rethrows)
+    case .throw: return TokenSpec(.throw, allowAtStartOfLine: false)
+    case .throws: return .keyword(.throws)
+    case .try: return TokenSpec(.try, allowAtStartOfLine: false)
+    }
+  }
+}