Remove Keyword suffix from Pound*

Author: kimdv

CodeGeneration/Sources/SyntaxSupport/Classification.swift

@@ -56,7 +56,7 @@ public let SYNTAX_CLASSIFICATIONS: [SyntaxClassification] = [
   SyntaxClassification(name: "None", description: "The token should not receive syntax coloring."),
   SyntaxClassification(name: "ObjectLiteral", description: "An image, color, etc. literal."),
   SyntaxClassification(name: "OperatorIdentifier", description: "An identifier referring to an operator."),
-  SyntaxClassification(name: "PoundDirectiveKeyword", description: "A `#` keyword like `#warning`."),
+  SyntaxClassification(name: "PoundDirective", description: "A `#` token like `#warning`."),
   SyntaxClassification(name: "RegexLiteral", description: "A regex literal, including multiline regex literals."),
   SyntaxClassification(name: "StringInterpolationAnchor", description: "The opening and closing parenthesis of string interpolation."),
   SyntaxClassification(name: "StringLiteral", description: "A string literal including multiline string literals."),

CodeGeneration/Sources/SyntaxSupport/TokenSpec.swift

@@ -18,19 +18,12 @@ public class TokenSpec {
   public let unprefixedKind: String
   public let text: String?
   public let classification: SyntaxClassification?
-  public let isKeyword: Bool
   public let requiresLeadingSpace: Bool
   public let requiresTrailingSpace: Bool
   public let associatedValueClass: String?
 
   public var swiftKind: String {
-    let name = lowercaseFirstWord(name: self.name)
-
-    if isKeyword {
-      return name + "Keyword"
-    } else {
-      return name
-    }
+    return lowercaseFirstWord(name: self.name)
   }
 
   init(
@@ -40,7 +33,6 @@ public class TokenSpec {
     unprefixedKind: String? = nil,
     text: String? = nil,
     classification: String = "None",
-    isKeyword: Bool = false,
     requiresLeadingSpace: Bool = false,
     requiresTrailingSpace: Bool = false,
     associatedValueClass: String? = nil
@@ -55,20 +47,19 @@ public class TokenSpec {
     }
     self.text = text
     self.classification = classificationByName(classification)
-    self.isKeyword = isKeyword
     self.requiresLeadingSpace = requiresLeadingSpace
     self.requiresTrailingSpace = requiresTrailingSpace
     self.associatedValueClass = associatedValueClass
   }
 }
 
-public class PoundKeywordSpec: TokenSpec {
+public class PoundSpec: TokenSpec {
   init(
     name: String,
     kind: String,
     nameForDiagnostics: String? = nil,
     text: String,
-    classification: String = "Keyword"
+    classification: String = "None"
   ) {
     super.init(
       name: name,
@@ -77,13 +68,12 @@ public class PoundKeywordSpec: TokenSpec {
       unprefixedKind: kind,
       text: text,
       classification: classification,
-      isKeyword: true,
       requiresTrailingSpace: true
     )
   }
 }
 
-public class PoundObjectLiteralSpec: PoundKeywordSpec {
+public class PoundObjectLiteralSpec: PoundSpec {
   let `protocol`: String
 
   init(
@@ -105,14 +95,14 @@ public class PoundObjectLiteralSpec: PoundKeywordSpec {
   }
 }
 
-public class PoundConfigSpec: PoundKeywordSpec {}
+public class PoundConfigSpec: PoundSpec {}
 
-public class PoundDirectiveKeywordSpec: PoundKeywordSpec {
+public class PoundDirectiveSpec: PoundSpec {
   init(
     name: String,
     kind: String,
     text: String,
-    classification: String = "PoundDirectiveKeyword"
+    classification: String = "PoundDirective"
   ) {
     super.init(
       name: name,
@@ -123,12 +113,12 @@ public class PoundDirectiveKeywordSpec: PoundKeywordSpec {
   }
 }
 
-public class PoundConditionalDirectiveKeywordSpec: PoundDirectiveKeywordSpec {
+public class PoundConditionalDirectiveSpec: PoundDirectiveSpec {
   override init(
     name: String,
     kind: String,
     text: String,
-    classification: String = "PoundDirectiveKeyword"
+    classification: String = "PoundDirective"
   ) {
     super.init(
       name: name,
@@ -155,7 +145,6 @@ public class PunctuatorSpec: TokenSpec {
       unprefixedKind: nil,
       text: text,
       classification: classification,
-      isKeyword: false,
       requiresLeadingSpace: requiresLeadingSpace,
       requiresTrailingSpace: requiresTrailingSpace
     )
@@ -201,11 +190,11 @@ public let SYNTAX_TOKENS: [TokenSpec] = [
   PunctuatorSpec(name: "PostfixQuestionMark", kind: "question_postfix", text: "?"),
   PunctuatorSpec(name: "Pound", kind: "pound", text: "#"),
   PoundConfigSpec(name: "PoundAvailable", kind: "pound_available", text: "#available"),
-  PoundConditionalDirectiveKeywordSpec(name: "PoundElse", kind: "pound_else", text: "#else"),
-  PoundConditionalDirectiveKeywordSpec(name: "PoundElseif", kind: "pound_elseif", text: "#elseif"),
-  PoundConditionalDirectiveKeywordSpec(name: "PoundEndif", kind: "pound_endif", text: "#endif"),
-  PoundConditionalDirectiveKeywordSpec(name: "PoundIf", kind: "pound_if", text: "#if"),
-  PoundDirectiveKeywordSpec(name: "PoundSourceLocation", kind: "pound_sourceLocation", text: "#sourceLocation"),
+  PoundConditionalDirectiveSpec(name: "PoundElse", kind: "pound_else", text: "#else"),
+  PoundConditionalDirectiveSpec(name: "PoundElseif", kind: "pound_elseif", text: "#elseif"),
+  PoundConditionalDirectiveSpec(name: "PoundEndif", kind: "pound_endif", text: "#endif"),
+  PoundConditionalDirectiveSpec(name: "PoundIf", kind: "pound_if", text: "#if"),
+  PoundDirectiveSpec(name: "PoundSourceLocation", kind: "pound_sourceLocation", text: "#sourceLocation"),
   PoundConfigSpec(name: "PoundUnavailable", kind: "pound_unavailable", text: "#unavailable"),
   PunctuatorSpec(name: "PrefixAmpersand", kind: "amp_prefix", text: "&"),
   MiscSpec(name: "PrefixOperator", kind: "oper_prefix", nameForDiagnostics: "prefix operator", classification: "OperatorIdentifier"),

CodeGeneration/Sources/Utils/SyntaxBuildableChild.swift

@@ -71,9 +71,6 @@ public extension Child {
     guard let token = token, isToken else {
       return type.defaultValue.map { InitializerClauseSyntax(value: $0) }
     }
-    if token.isKeyword {
-      return InitializerClauseSyntax(value: ExprSyntax(".\(raw: token.swiftKind)()"))
-    }
     if token.name == "EOF" {
       return InitializerClauseSyntax(value: ExprSyntax(".eof()"))
     }

CodeGeneration/Sources/Utils/SyntaxBuildableType.swift

@@ -63,9 +63,7 @@ public struct SyntaxBuildableType: Hashable {
     if isOptional {
       return ExprSyntax(NilLiteralExprSyntax())
     } else if let token = token {
-      if token.isKeyword {
-        return ExprSyntax(".\(raw: token.swiftKind)()")
-      } else if token.text != nil {
+      if token.text != nil {
         return ExprSyntax(".\(raw: lowercaseFirstWord(name: token.name))Token()")
       }
     } else if case .token("EOFToken") = kind {

CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/IsLexerClassifiedFile.swift

@@ -62,12 +62,6 @@ let isLexerClassifiedFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
           StmtSyntax("return false")
         }
 
-        for token in SYNTAX_TOKENS where token.isKeyword {
-          SwitchCaseSyntax("case .\(raw: token.swiftKind):") {
-            StmtSyntax("return true")
-          }
-        }
-
         SwitchCaseSyntax("case .keyword(let keyword):") {
           StmtSyntax("return keyword.isLexerClassified")
         }

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

@@ -18,24 +18,7 @@ import Utils
 let tokensFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
   try! ExtensionDeclSyntax("extension TokenSyntax") {
     for token in SYNTAX_TOKENS {
-      if token.isKeyword {
-        DeclSyntax(
-          """
-          public static func \(raw: token.swiftKind)(
-            leadingTrivia: Trivia = [],
-            trailingTrivia: Trivia = [],
-            presence: SourcePresence = .present
-          ) -> TokenSyntax {
-            return TokenSyntax(
-              .\(raw: token.swiftKind),
-              leadingTrivia: leadingTrivia,
-              trailingTrivia: trailingTrivia,
-              presence: presence
-            )
-          }
-          """
-        )
-      } else if let text = token.text {
+      if let text = token.text {
         DeclSyntax(
           """
           public static func \(raw: token.swiftKind)Token(

Sources/SwiftBasicFormat/BasicFormat.swift

@@ -192,9 +192,9 @@ open class BasicFormat: SyntaxRewriter {
       (.multilineStringQuote, .stringSegment),  // segment starting a multi-line string literal
       (.stringSegment, .multilineStringQuote),  // ending a multi-line string literal that has a string interpolation segment at its end
       (.rightParen, .multilineStringQuote),  // ending a multi-line string literal that has a string interpolation segment at its end
-      (_, .poundElseKeyword),
-      (_, .poundElseifKeyword),
-      (_, .poundEndifKeyword),
+      (_, .poundElse),
+      (_, .poundElseif),
+      (_, .poundEndif),
       (_, .rightBrace):
       return true
     default:
@@ -235,7 +235,7 @@ open class BasicFormat: SyntaxRewriter {
       (.postfixQuestionMark, .leftParen),  // init?() or myOptionalClosure?()
       (.postfixQuestionMark, .period),  // someOptional?.someProperty
       (.pound, _),
-      (.poundUnavailableKeyword, .leftParen),  // #unavailable(...)
+      (.poundUnavailable, .leftParen),  // #unavailable(...)
       (.prefixAmpersand, _),
       (.prefixOperator, _),
       (.rawStringDelimiter, .leftParen),  // opening raw string delimiter should never be separate by a space

Sources/SwiftIDEUtils/CMakeLists.txt

@@ -8,6 +8,8 @@
 
 add_swift_host_library(SwiftIDEUtils
   generated/SyntaxClassification.swift
+
+  SwiftIDEUtilsCompatibility.swift
   Syntax+Classifications.swift
   SyntaxClassifier.swift
 )

Sources/SwiftIDEUtils/SwiftIDEUtilsCompatibility.swift

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This file provides compatiblity aliases to keep dependents of SwiftSyntax building.
+// All users of the declarations in this file should transition away from them ASAP.
+
+public extension SyntaxClassification {
+  /// A `#` keyword like `#warning`.
+  @available(*, deprecated, renamed: "poundDirective")
+  static var poundDirectiveKeyword: SyntaxClassification {
+    return .poundDirective
+  }
+}
+
+//==========================================================================//
+// IMPORTANT: If you are tempted to add a compatiblity layer code here      //
+// please insert it in alphabetical order above                             //
+//==========================================================================//

Sources/SwiftIDEUtils/generated/SyntaxClassification.swift

@@ -45,8 +45,8 @@ public enum SyntaxClassification {
   case objectLiteral
   /// An identifier referring to an operator.
   case operatorIdentifier
-  /// A `#` keyword like `#warning`.
-  case poundDirectiveKeyword
+  /// A `#` token like `#warning`.
+  case poundDirective
   /// A regex literal, including multiline regex literals.
   case regexLiteral
   /// The opening and closing parenthesis of string interpolation.
@@ -156,20 +156,20 @@ extension RawTokenKind {
       return .none
     case .pound:
       return .none
-    case .poundAvailableKeyword:
-      return .keyword
-    case .poundElseKeyword:
-      return .poundDirectiveKeyword
-    case .poundElseifKeyword:
-      return .poundDirectiveKeyword
-    case .poundEndifKeyword:
-      return .poundDirectiveKeyword
-    case .poundIfKeyword:
-      return .poundDirectiveKeyword
-    case .poundSourceLocationKeyword:
-      return .poundDirectiveKeyword
-    case .poundUnavailableKeyword:
-      return .keyword
+    case .poundAvailable:
+      return .none
+    case .poundElse:
+      return .poundDirective
+    case .poundElseif:
+      return .poundDirective
+    case .poundEndif:
+      return .poundDirective
+    case .poundIf:
+      return .poundDirective
+    case .poundSourceLocation:
+      return .poundDirective
+    case .poundUnavailable:
+      return .none
     case .prefixAmpersand:
       return .none
     case .prefixOperator:

Sources/SwiftParser/Attributes.swift

@@ -14,7 +14,7 @@
 
 extension Parser {
   mutating func parseAttributeList() -> RawAttributeListSyntax? {
-    guard self.at(.atSign, .poundIfKeyword) else {
+    guard self.at(.atSign, .poundIf) else {
       return nil
     }
 
@@ -23,7 +23,7 @@ extension Parser {
     repeat {
       let attribute = self.parseAttribute()
       elements.append(attribute)
-    } while self.at(.atSign, .poundIfKeyword) && loopProgress.evaluate(currentToken)
+    } while self.at(.atSign, .poundIf) && loopProgress.evaluate(currentToken)
     return RawAttributeListSyntax(elements: elements, arena: self.arena)
   }
 }
@@ -213,7 +213,7 @@ extension Parser {
   }
 
   mutating func parseAttribute() -> RawAttributeListSyntax.Element {
-    if self.at(.poundIfKeyword) {
+    if self.at(.poundIf) {
       return .ifConfigDecl(
         self.parsePoundIfDirective { (parser, _) -> RawAttributeListSyntax.Element in
           return parser.parseAttribute()

Sources/SwiftParser/Declarations.swift

@@ -53,7 +53,7 @@ extension TokenConsumer {
     allowInitDecl: Bool = true,
     allowRecovery: Bool = false
   ) -> Bool {
-    if self.at(.poundIfKeyword) {
+    if self.at(.poundIf) {
       return true
     }
 
@@ -85,12 +85,12 @@ extension TokenConsumer {
     }
 
     if hasAttribute {
-      if subparser.at(.rightBrace) || subparser.at(.eof) || subparser.at(.poundEndifKeyword) {
+      if subparser.at(.rightBrace) || subparser.at(.eof) || subparser.at(.poundEndif) {
         return true
       }
     }
 
-    if subparser.at(.poundIfKeyword) {
+    if subparser.at(.poundIf) {
       var attrLookahead = subparser.lookahead()
       return attrLookahead.consumeIfConfigOfAttributes()
     }
@@ -196,7 +196,7 @@ extension Parser {
   mutating func parseDeclaration(inMemberDeclList: Bool = false) -> RawDeclSyntax {
     // If we are at a `#if` of attributes, the `#if` directive should be
     // parsed when we're parsing the attributes.
-    if self.at(.poundIfKeyword) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) {
+    if self.at(.poundIf) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) {
       let directive = self.parsePoundIfDirective { (parser, _) in
         let parsedDecl = parser.parseDeclaration()
         let semicolon = parser.consume(if: .semicolon)
@@ -744,7 +744,7 @@ extension Parser {
     }
 
     let decl: RawDeclSyntax
-    if self.at(.poundSourceLocationKeyword) {
+    if self.at(.poundSourceLocation) {
       decl = RawDeclSyntax(self.parsePoundSourceLocationDirective())
     } else {
       decl = self.parseDeclaration(inMemberDeclList: true)