Remove a last at function that took an array

Author: ahoppen

Sources/SwiftParser/Expressions.swift

@@ -2225,7 +2225,7 @@ extension Parser {
   public mutating func parseSwitchCases(allowStandaloneStmtRecovery: Bool) -> RawSwitchCaseListSyntax {
     var elements = [RawSwitchCaseListSyntax.Element]()
     var elementsProgress = LoopProgressCondition()
-    while !self.at(any: [.eof, .rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword])
+    while !self.at(.eof, .rightBrace) && !self.at(.poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword)
       && elementsProgress.evaluate(currentToken)
     {
       if self.withLookahead({ $0.isAtStartOfSwitchCase(allowRecovery: false) }) {
@@ -2294,7 +2294,7 @@ extension Parser {
   mutating func parseSwitchCaseBody() -> RawCodeBlockItemListSyntax {
     var items = [RawCodeBlockItemSyntax]()
     var loopProgress = LoopProgressCondition()
-    while !self.at(any: [.rightBrace, .poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword])
+    while !self.at(.rightBrace) && !self.at(.poundEndifKeyword, .poundElseifKeyword, .poundElseKeyword)
       && !self.withLookahead({ $0.isStartOfConditionalSwitchCases() }),
       let newItem = self.parseCodeBlockItem(),
       loopProgress.evaluate(currentToken)

Sources/SwiftParser/Statements.swift

@@ -629,11 +629,48 @@ extension Parser {
 
 extension Parser {
   private mutating func isStartOfReturnExpr() -> Bool {
-    if self.at(any: [
-      .rightBrace, .keyword(.case), .keyword(.default), .semicolon, .eof,
-      .poundIfKeyword, .poundEndifKeyword, .poundElseKeyword,
-      .poundElseifKeyword,
-    ]) {
+    enum NotReturnExprStart: TokenSpecSet {
+      case rightBrace
+      case `case`
+      case `default`
+      case semicolon
+      case poundIfKeyword
+      case poundEndifKeyword
+      case poundElseKeyword
+      case poundElseifKeyword
+      case eof
+
+      init?(lexeme: Lexer.Lexeme) {
+        switch lexeme {
+        case TokenSpec(.rightBrace): self = .rightBrace
+        case TokenSpec(.case): self = .case
+        case TokenSpec(.default): self = .default
+        case TokenSpec(.semicolon): self = .semicolon
+        case TokenSpec(.poundIfKeyword): self = .poundIfKeyword
+        case TokenSpec(.poundEndifKeyword): self = .poundEndifKeyword
+        case TokenSpec(.poundElseKeyword): self = .poundElseKeyword
+        case TokenSpec(.poundElseifKeyword): self = .poundElseifKeyword
+        case TokenSpec(.eof): self = .eof
+        default: return nil
+        }
+      }
+
+      var spec: TokenSpec {
+        switch self {
+        case .rightBrace: return .rightBrace
+        case .case: return .keyword(.case)
+        case .default: return .keyword(.default)
+        case .semicolon: return .semicolon
+        case .poundIfKeyword: return .poundIfKeyword
+        case .poundEndifKeyword: return .poundEndifKeyword
+        case .poundElseKeyword: return .poundElseKeyword
+        case .poundElseifKeyword: return .poundElseifKeyword
+        case .eof: return .eof
+        }
+      }
+    }
+
+    if self.at(anyIn: NotReturnExprStart.self) != nil {
       return false
     }
     // Allowed for if/switch expressions.

Sources/SwiftParser/TokenConsumer.swift

@@ -88,18 +88,6 @@ extension TokenConsumer {
     return self.currentToken.isContextualPunctuator(name)
   }
 
-  /// Returns whether the kind of the current token is any of the given
-  /// kinds and additionally satisfies `condition`.
-  ///
-  /// - Parameter kinds: The kinds to test for.
-  /// - Parameter condition: An additional condition that must be satisfied for
-  ///                        this function to return `true`.
-  /// - Returns: `true` if the current token's kind is in `kinds`.
-  @inline(__always)
-  mutating func at(any kinds: [RawTokenKind]) -> Bool {
-    return kinds.contains(where: { TokenSpec($0) ~= self.currentToken })
-  }
-
   /// Checks whether the parser is currently positioned at any token in `Subset`.
   /// If this is the case, return the `Subset` case that the parser is positioned in
   /// as well as a handle to consume that token.