Adjustments for merging of contextual and lexical keywords

Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift

@@ -1718,7 +1718,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
     // this special exception for `async let` statements to avoid breaking prematurely between the
     // `async` and `let` keywords.
     let breakOrSpace: Token
-    if node.name.tokenKind == .contextualKeyword(.async) {
+    if node.name.tokenKind == .keyword(.async) {
       breakOrSpace = .space
     } else {
       breakOrSpace = .break

Sources/SwiftFormatRules/AlwaysUseLowerCamelCase.swift

@@ -173,9 +173,9 @@ fileprivate func identifierDescription<NodeType: SyntaxProtocol>(for node: NodeT
   case .enumCaseElement: return "enum case"
   case .functionDecl: return "function"
   case .optionalBindingCondition(let binding):
-    return binding.letOrVarKeyword.tokenKind == .varKeyword ? "variable" : "constant"
+    return binding.letOrVarKeyword.tokenKind == .keyword(.var) ? "variable" : "constant"
   case .variableDecl(let variableDecl):
-    return variableDecl.letOrVarKeyword.tokenKind == .varKeyword ? "variable" : "constant"
+    return variableDecl.letOrVarKeyword.tokenKind == .keyword(.var) ? "variable" : "constant"
   default:
     return "identifier"
   }

Sources/SwiftFormatRules/FileScopedDeclarationPrivacy.swift

@@ -144,12 +144,12 @@ public final class FileScopedDeclarationPrivacy: SyntaxFormatRule {
 
     switch context.configuration.fileScopedDeclarationPrivacy.accessLevel {
     case .private:
-      invalidAccess = .fileprivateKeyword
-      validAccess = .privateKeyword
+      invalidAccess = .keyword(.fileprivate)
+      validAccess = .keyword(.private)
       diagnostic = .replaceFileprivateWithPrivate
     case .fileprivate:
-      invalidAccess = .privateKeyword
-      validAccess = .fileprivateKeyword
+      invalidAccess = .keyword(.private)
+      validAccess = .keyword(.fileprivate)
       diagnostic = .replacePrivateWithFileprivate
     }
 

Sources/SwiftFormatRules/FullyIndirectEnum.swift

@@ -57,7 +57,7 @@ public final class FullyIndirectEnum: SyntaxFormatRule {
     let leadingTrivia: Trivia
     let newEnumDecl: EnumDeclSyntax
 
-    if firstTok.tokenKind == .enumKeyword {
+    if firstTok.tokenKind == .keyword(.enum) {
       leadingTrivia = firstTok.leadingTrivia
       newEnumDecl = replaceTrivia(
         on: node, token: node.firstToken, leadingTrivia: [])

Sources/SwiftFormatRules/ModifierListSyntax+Convenience.swift

@@ -26,7 +26,7 @@ extension ModifierListSyntax {
   var accessLevelModifier: DeclModifierSyntax? {
     for modifier in self {
       switch modifier.name.tokenKind {
-      case .publicKeyword, .privateKeyword, .fileprivateKeyword, .internalKeyword:
+      case .keyword(.public), .keyword(.private), .keyword(.fileprivate), .keyword(.internal):
         return modifier
       default:
         continue

Sources/SwiftFormatRules/NoAccessLevelOnExtensionDeclaration.swift

@@ -31,15 +31,15 @@ public final class NoAccessLevelOnExtensionDeclaration: SyntaxFormatRule {
     let keywordKind = accessKeyword.name.tokenKind
     switch keywordKind {
     // Public, private, or fileprivate keywords need to be moved to members
-    case .publicKeyword, .privateKeyword, .fileprivateKeyword:
+    case .keyword(.public), .keyword(.private), .keyword(.fileprivate):
       diagnose(.moveAccessKeyword(keyword: accessKeyword.name.text), on: accessKeyword)
 
       // The effective access level of the members of a `private` extension is `fileprivate`, so
       // we have to update the keyword to ensure that the result is correct.
       let accessKeywordToAdd: DeclModifierSyntax
-      if keywordKind == .privateKeyword {
+      if keywordKind == .keyword(.private) {
         accessKeywordToAdd
-          = accessKeyword.withName(accessKeyword.name.withKind(.fileprivateKeyword))
+          = accessKeyword.withName(accessKeyword.name.withKind(.keyword(.fileprivate)))
       } else {
         accessKeywordToAdd = accessKeyword
       }
@@ -58,7 +58,7 @@ public final class NoAccessLevelOnExtensionDeclaration: SyntaxFormatRule {
       return DeclSyntax(result)
 
     // Internal keyword redundant, delete
-    case .internalKeyword:
+    case .keyword(.internal):
       diagnose(
         .removeRedundantAccessKeyword(name: node.extendedType.description),
         on: accessKeyword)

Sources/SwiftFormatRules/UseEarlyExits.swift

@@ -67,13 +67,13 @@ public final class UseEarlyExits: SyntaxFormatRule {
 
         let trueBlock = ifStatement.body
 
-        let guardKeyword = TokenSyntax.guardKeyword(
+        let guardKeyword = TokenSyntax.keyword(.guard,
           leadingTrivia: ifStatement.ifKeyword.leadingTrivia,
           trailingTrivia: .spaces(1))
         let guardStatement = GuardStmtSyntax(
           guardKeyword: guardKeyword,
           conditions: ifStatement.conditions,
-          elseKeyword: TokenSyntax.elseKeyword(trailingTrivia: .spaces(1)),
+          elseKeyword: TokenSyntax.keyword(.else, trailingTrivia: .spaces(1)),
           body: elseBody)
 
         var items = [

Sources/SwiftFormatRules/UseShorthandTypeNames.swift

@@ -520,12 +520,12 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
       // Look for accessors that indicate that this is a computed property. If none are found, then
       // it is a stored property (e.g., having only observers like `willSet/didSet`).
       switch accessorDecl.accessorKind.tokenKind {
-      case .contextualKeyword(.get),
-        .contextualKeyword(.set),
-        .contextualKeyword(.unsafeAddress),
-        .contextualKeyword(.unsafeMutableAddress),
-        .contextualKeyword(._read),
-        .contextualKeyword(._modify):
+      case .keyword(.get),
+        .keyword(.set),
+        .keyword(.unsafeAddress),
+        .keyword(.unsafeMutableAddress),
+        .keyword(._read),
+        .keyword(._modify):
         return false
       default:
         return true
@@ -545,7 +545,7 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
       isStoredProperty(patternBinding),
       patternBinding.initializer == nil,
       let variableDecl = nearestAncestor(of: patternBinding, type: VariableDeclSyntax.self),
-      variableDecl.letOrVarKeyword.tokenKind == .varKeyword
+      variableDecl.letOrVarKeyword.tokenKind == .keyword(.var)
     {
       return true
     }

Sources/SwiftFormatRules/UseSingleLinePropertyGetter.swift

@@ -26,7 +26,7 @@ public final class UseSingleLinePropertyGetter: SyntaxFormatRule {
       let acc = accessorBlock.accessors.first,
       let body = acc.body,
       accessorBlock.accessors.count == 1,
-      acc.accessorKind.tokenKind == .contextualKeyword(.get),
+      acc.accessorKind.tokenKind == .keyword(.get),
       acc.attributes == nil,
       acc.modifier == nil,
       acc.asyncKeyword == nil,

Sources/SwiftFormatRules/UseSynthesizedInitializer.swift

@@ -90,11 +90,11 @@ public final class UseSynthesizedInitializer: SyntaxLintRule {
     switch synthesizedAccessLevel {
     case .internal:
       // No explicit access level or internal are equivalent.
-      return accessLevel == nil || accessLevel!.name.tokenKind == .internalKeyword
+      return accessLevel == nil || accessLevel!.name.tokenKind == .keyword(.internal)
     case .fileprivate:
-      return accessLevel != nil && accessLevel!.name.tokenKind == .fileprivateKeyword
+      return accessLevel != nil && accessLevel!.name.tokenKind == .keyword(.fileprivate)
     case .private:
-      return accessLevel != nil && accessLevel!.name.tokenKind == .privateKeyword
+      return accessLevel != nil && accessLevel!.name.tokenKind == .keyword(.private)
     }
   }
 
@@ -116,7 +116,7 @@ public final class UseSynthesizedInitializer: SyntaxLintRule {
       // Ensure that parameters that correspond to properties declared using 'var' have a default
       // argument that is identical to the property's default value. Otherwise, a default argument
       // doesn't match the memberwise initializer.
-      let isVarDecl = property.letOrVarKeyword.tokenKind == .varKeyword
+      let isVarDecl = property.letOrVarKeyword.tokenKind == .keyword(.var)
       if isVarDecl, let initializer = property.firstInitializer {
         guard let defaultArg = parameter.defaultArgument else { return false }
         guard initializer.value.description == defaultArg.value.description else { return false }
@@ -212,10 +212,10 @@ fileprivate func synthesizedInitAccessLevel(using properties: [VariableDeclSynta
     guard let modifiers = property.modifiers else { continue }
 
     // Private takes precedence, so finding 1 private property defines the access level.
-    if modifiers.contains(where: {$0.name.tokenKind == .privateKeyword && $0.detail == nil}) {
+    if modifiers.contains(where: {$0.name.tokenKind == .keyword(.private) && $0.detail == nil}) {
       return .private
     }
-    if modifiers.contains(where: {$0.name.tokenKind == .fileprivateKeyword && $0.detail == nil}) {
+    if modifiers.contains(where: {$0.name.tokenKind == .keyword(.fileprivate) && $0.detail == nil}) {
       hasFileprivate = true
       // Can't break here because a later property might be private.
     }

Sources/SwiftFormatRules/UseWhereClausesInForLoops.swift

@@ -101,7 +101,7 @@ fileprivate func updateWithWhereCondition(
   if lastToken?.trailingTrivia.containsSpaces == false {
     whereLeadingTrivia = .spaces(1)
   }
-  let whereKeyword = TokenSyntax.whereKeyword(
+  let whereKeyword = TokenSyntax.keyword(.where,
     leadingTrivia: whereLeadingTrivia,
     trailingTrivia: .spaces(1)
   )

Sources/SwiftFormatRules/ValidateDocumentationComments.swift

@@ -121,7 +121,7 @@ public final class ValidateDocumentationComments: SyntaxLintRule {
     // If a function is marked as `rethrows`, it doesn't have any errors of its
     // own that should be documented. So only require documentation for
     // functions marked `throws`.
-    let needsThrowsDesc = throwsOrRethrowsKeyword?.tokenKind == .throwsKeyword
+    let needsThrowsDesc = throwsOrRethrowsKeyword?.tokenKind == .keyword(.throws)
 
     if !needsThrowsDesc && throwsDesc != nil {
       diagnose(.removeThrowsComment(funcName: name), on: throwsOrRethrowsKeyword ?? node.firstToken)