A couple of miscellaneous implementation improvements in the parser

Author: ahoppen

Sources/SwiftParser/Expressions.swift

@@ -588,21 +588,18 @@ extension Parser {
     // First check to see if we have the start of a regex literal `/.../`.
     //    tryLexRegexLiteral(/*forUnappliedOperator*/ false)
 
-    switch self.currentToken {
     // Try parse an 'if' or 'switch' as an expression. Note we do this here in
     // parseUnaryExpression as we don't allow postfix syntax to hang off such
     // expressions to avoid ambiguities such as postfix '.member', which can
     // currently be parsed as a static dot member for a result builder.
-    case TokenSpec(.switch):
+    if self.at(.keyword(.switch)) {
       return RawExprSyntax(
         parseSwitchExpression(switchHandle: .constant(.keyword(.switch)))
       )
-    case TokenSpec(.if):
+    } else if self.at(.keyword(.if)) {
       return RawExprSyntax(
         parseIfExpression(ifHandle: .constant(.keyword(.if)))
       )
-    default:
-      break
     }
 
     switch self.at(anyIn: ExpressionPrefixOperator.self) {
@@ -950,7 +947,7 @@ extension Parser {
         // Check if the first '#if' body starts with '.' <identifier>, and parse
         // it as a "postfix ifconfig expression".
         do {
-          var backtrack = self.lookahead()
+          var lookahead = self.lookahead()
           // Skip to the first body. We may need to skip multiple '#if' directives
           // since we support nested '#if's. e.g.
           //   baseExpr
@@ -959,13 +956,13 @@ extension Parser {
           //       .someMember
           var loopProgress = LoopProgressCondition()
           repeat {
-            backtrack.eat(.poundIfKeyword)
-            while !backtrack.at(.endOfFile) && !backtrack.currentToken.isAtStartOfLine {
-              backtrack.skipSingle()
+            lookahead.eat(.poundIfKeyword)
+            while !lookahead.at(.endOfFile) && !lookahead.atStartOfLine {
+              lookahead.skipSingle()
             }
-          } while backtrack.at(.poundIfKeyword) && loopProgress.evaluate(backtrack.currentToken)
+          } while lookahead.at(.poundIfKeyword) && loopProgress.evaluate(backtrack.currentToken)
 
-          guard backtrack.isAtStartOfPostfixExprSuffix() else {
+          guard lookahead.isAtStartOfPostfixExprSuffix() else {
             break
           }
         }

Sources/SwiftParser/Nominals.swift

@@ -223,9 +223,9 @@ extension Parser {
         inheritanceClause: nil,
         genericWhereClause: nil,
         memberBlock: RawMemberDeclBlockSyntax(
-          leftBrace: RawTokenSyntax(missing: .leftBrace, arena: self.arena),
+          leftBrace: missingToken(.leftBrace),
           members: RawMemberDeclListSyntax(elements: [], arena: self.arena),
-          rightBrace: RawTokenSyntax(missing: .rightBrace, arena: self.arena),
+          rightBrace: missingToken(.rightBrace),
           arena: self.arena
         ),
         arena: self.arena

Sources/SwiftParser/Statements.swift

@@ -921,7 +921,7 @@ extension Parser {
 
   // label-name → identifier
   mutating func parseOptionalControlTransferTarget() -> RawTokenSyntax? {
-    guard !self.currentToken.isAtStartOfLine else {
+    guard !self.atStartOfLine else {
       return nil
     }
 

Sources/SwiftParser/TokenConsumer.swift

@@ -128,7 +128,7 @@ extension TokenConsumer {
   /// If this is the case, return the `Subset` case that the parser is positioned in
   /// as well as a handle to consume that token.
   @inline(__always)
-  mutating func at<SpecSet: TokenSpecSet>(anyIn specSet: SpecSet.Type) -> (SpecSet, TokenConsumptionHandle)? {
+  mutating func at<SpecSet: TokenSpecSet>(anyIn specSet: SpecSet.Type) -> (spec: SpecSet, handle: TokenConsumptionHandle)? {
     #if SWIFTPARSER_ENABLE_ALTERNATE_TOKEN_INTROSPECTION
     if shouldRecordAlternativeTokenChoices {
       recordAlternativeTokenChoice(for: self.currentToken, choices: specSet.allCases.map(\.spec))

Sources/SwiftParser/Types.swift

@@ -235,19 +235,49 @@ extension Parser {
   mutating func parseSimpleType(
     stopAtFirstPeriod: Bool = false
   ) -> RawTypeSyntax {
+    enum TypeBaseStart: TokenSpecSet {
+      case `Self`
+      case `Any`
+      case identifier
+      case leftParen
+      case leftSquare
+      case wildcard
+
+      init?(lexeme: Lexer.Lexeme) {
+        switch PrepareForKeywordMatch(lexeme) {
+        case .keyword(.Self): self = .Self
+        case .keyword(.Any): self = .Any
+        case .identifier: self = .identifier
+        case .leftParen: self = .leftParen
+        case .leftSquare: self = .leftSquare
+        case .wildcard: self = .wildcard
+        default: return nil
+        }
+      }
+
+      var spec: TokenSpec {
+        switch self {
+        case .Self: return .keyword(.Self)
+        case .Any: return .keyword(.Any)
+        case .identifier: return .identifier
+        case .leftParen: return .leftParen
+        case .leftSquare: return .leftSquare
+        case .wildcard: return .wildcard
+        }
+      }
+    }
+
     var base: RawTypeSyntax
-    switch self.currentToken {
-    case TokenSpec(.Self),
-      TokenSpec(.Any),
-      TokenSpec(.identifier):
+    switch self.at(anyIn: TypeBaseStart.self)?.spec {
+    case .Self, .Any, .identifier:
       base = self.parseTypeIdentifier()
-    case TokenSpec(.leftParen):
+    case .leftParen:
       base = RawTypeSyntax(self.parseTupleTypeBody())
-    case TokenSpec(.leftSquare):
+    case .leftSquare:
       base = RawTypeSyntax(self.parseCollectionType())
-    case TokenSpec(.wildcard):
+    case .wildcard:
       base = RawTypeSyntax(self.parsePlaceholderType())
-    default:
+    case nil:
       return RawTypeSyntax(RawMissingTypeSyntax(arena: self.arena))
     }