Remove isLexerClassifiedKeyword from RawTokenKind

Author: ahoppen

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TokenKindFile.swift

@@ -304,32 +304,6 @@ let tokenKindFile = SourceFileSyntax {
       }
     }
 
-    try! VariableDeclSyntax(
-      """
-      /// Returns `true` if the token is a Swift keyword.
-      ///
-      /// Keywords are reserved unconditionally for use by Swift and may not
-      /// appear as identifiers in any position without being escaped. For example,
-      /// `class`, `func`, or `import`.
-      public var isLexerClassifiedKeyword: Bool
-      """
-    ) {
-      try! SwitchExprSyntax("switch self.base") {
-        SwitchCaseSyntax("case .eof:") {
-          StmtSyntax("return false")
-        }
-
-        for token in SYNTAX_TOKENS where token.swiftKind != "keyword" {
-          SwitchCaseSyntax("case .\(raw: token.swiftKind):") {
-            StmtSyntax("return \(raw: token.isKeyword)")
-          }
-        }
-        SwitchCaseSyntax("case .keyword:") {
-          StmtSyntax("return self.keyword.isLexerClassified")
-        }
-      }
-    }
-
     try! VariableDeclSyntax(
       """
       /// Returns `true` if the token is a Swift punctuator.

Sources/SwiftParser/Expressions.swift

@@ -2562,7 +2562,7 @@ extension Parser.Lookahead {
     if self.peek().rawTokenKind != .identifier,
       self.peek().rawTokenKind != .keyword(.Self),
       self.peek().rawTokenKind != .keyword(.self),
-      !self.peek().rawTokenKind.isLexerClassifiedKeyword
+      !self.peek().isLexerClassifiedKeyword
     {
       return false
     }

Sources/SwiftParser/Names.swift

@@ -68,7 +68,7 @@ extension Parser {
       ident = self.expectIdentifierWithoutRecovery()
     } else if flags.contains(.operators), let (_, _) = self.at(anyIn: Operator.self) {
       ident = self.consumeAnyToken(remapping: .binaryOperator)
-    } else if flags.contains(.keywords) && self.currentToken.rawTokenKind.isLexerClassifiedKeyword {
+    } else if flags.contains(.keywords) && self.currentToken.isLexerClassifiedKeyword {
       ident = self.consumeAnyToken(remapping: .identifier)
     } else {
       ident = self.expectIdentifierWithoutRecovery()
@@ -279,7 +279,10 @@ extension Lexer.Lexeme {
   }
 
   var isLexerClassifiedKeyword: Bool {
-    self.rawTokenKind.isLexerClassifiedKeyword
+    // Only lexer-classified lexemes have `RawTokenKind` of `keyword.
+    // Contextual keywords will only be made keywords when a `RawTokenSyntax` is
+    // constructed from them.
+    return self.rawTokenKind.base == .keyword
   }
 
   func starts(with symbol: SyntaxText) -> Bool {

Sources/SwiftParser/Parser.swift

@@ -427,7 +427,7 @@ extension Parser {
         self.missingToken(.identifier, text: nil)
       )
     } else if keywordRecovery,
-      (self.currentToken.rawTokenKind.isLexerClassifiedKeyword || self.currentToken.rawTokenKind == .wildcard),
+      (self.currentToken.isLexerClassifiedKeyword || self.currentToken.rawTokenKind == .wildcard),
       !self.currentToken.isAtStartOfLine
     {
       let keyword = self.consumeAnyToken()

Sources/SwiftParser/Patterns.swift

@@ -131,7 +131,7 @@ extension Parser {
         )
       )
     case nil:
-      if self.currentToken.rawTokenKind.isLexerClassifiedKeyword, !self.currentToken.isAtStartOfLine {
+      if self.currentToken.isLexerClassifiedKeyword, !self.currentToken.isAtStartOfLine {
         // Recover if a keyword was used instead of an identifier
         let keyword = self.consumeAnyToken()
         return RawPatternSyntax(

Sources/SwiftSyntax/generated/TokenKind.swift

@@ -1095,110 +1095,6 @@ public struct RawTokenKind: Equatable, Hashable {
     }
   }
 
-  /// Returns `true` if the token is a Swift keyword.
-  ///
-  /// Keywords are reserved unconditionally for use by Swift and may not
-  /// appear as identifiers in any position without being escaped. For example,
-  /// `class`, `func`, or `import`.
-  public var isLexerClassifiedKeyword: Bool {
-    switch self.base {
-    case .eof: 
-      return false
-    case .wildcard: 
-      return false
-    case .leftParen: 
-      return false
-    case .rightParen: 
-      return false
-    case .leftBrace: 
-      return false
-    case .rightBrace: 
-      return false
-    case .leftSquareBracket: 
-      return false
-    case .rightSquareBracket: 
-      return false
-    case .leftAngle: 
-      return false
-    case .rightAngle: 
-      return false
-    case .period: 
-      return false
-    case .comma: 
-      return false
-    case .ellipsis: 
-      return false
-    case .colon: 
-      return false
-    case .semicolon: 
-      return false
-    case .equal: 
-      return false
-    case .atSign: 
-      return false
-    case .pound: 
-      return false
-    case .prefixAmpersand: 
-      return false
-    case .arrow: 
-      return false
-    case .backtick: 
-      return false
-    case .backslash: 
-      return false
-    case .exclamationMark: 
-      return false
-    case .postfixQuestionMark: 
-      return false
-    case .infixQuestionMark: 
-      return false
-    case .stringQuote: 
-      return false
-    case .singleQuote: 
-      return false
-    case .multilineStringQuote: 
-      return false
-    case .poundSourceLocationKeyword: 
-      return true
-    case .poundIfKeyword: 
-      return true
-    case .poundElseKeyword: 
-      return true
-    case .poundElseifKeyword: 
-      return true
-    case .poundEndifKeyword: 
-      return true
-    case .poundAvailableKeyword: 
-      return true
-    case .poundUnavailableKeyword: 
-      return true
-    case .integerLiteral: 
-      return false
-    case .floatingLiteral: 
-      return false
-    case .regexLiteral: 
-      return false
-    case .unknown: 
-      return false
-    case .identifier: 
-      return false
-    case .binaryOperator: 
-      return false
-    case .postfixOperator: 
-      return false
-    case .prefixOperator: 
-      return false
-    case .dollarIdentifier: 
-      return false
-    case .rawStringDelimiter: 
-      return false
-    case .stringSegment: 
-      return false
-    case .keyword: 
-      return self.keyword.isLexerClassified
-    }
-  }
-  
   /// Returns `true` if the token is a Swift punctuator.
   ///
   /// Punctuation tokens generally separate identifiers from each other. For