Replace the manually maintained TokenSpecSet TypeSpecifier by the generated TypeSpecifierSyntax.SpecifierOptions

The two `TokenSpecSet`s had already diverged. Instead of manually maintaining the `TypeSpecifier` spec set, we should allow all keywors specified in the syntax tree definition.

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/Child.swift

@@ -24,6 +24,15 @@ public enum TokenChoice: Equatable {
     case .token: return false
     }
   }
+
+  public var varOrCaseName: TokenSyntax {
+    switch self {
+    case .keyword(let keyword):
+      return keyword.spec.varOrCaseName
+    case .token(let token):
+      return token.spec.varOrCaseName
+    }
+  }
 }
 
 public enum ChildKind {

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -34,36 +34,6 @@ public let TYPE_NODES: [Node] = [
     ]
   ),
 
-  Node(
-    kind: .typeSpecifier,
-    base: .syntax,
-    nameForDiagnostics: nil,
-    documentation: "A specifier that can be attached to a type to eg. mark a parameter as `inout` or `consuming`",
-    children: [
-      Child(
-        name: "specifier",
-        kind: .token(choices: [
-          .keyword(.inout),
-          .keyword(.__shared),
-          .keyword(.__owned),
-          .keyword(.isolated),
-          .keyword(._const),
-          .keyword(.borrowing),
-          .keyword(.consuming),
-          .keyword(.transferring),
-          .keyword(._resultDependsOn),
-        ])
-      )
-    ]
-  ),
-
-  Node(
-    kind: .typeSpecifierList,
-    base: .syntaxCollection,
-    nameForDiagnostics: nil,
-    elementChoices: [.typeSpecifier]
-  ),
-
   Node(
     kind: .attributedType,
     base: .type,
@@ -74,15 +44,18 @@ public let TYPE_NODES: [Node] = [
     children: [
       Child(
         name: "specifiers",
-        kind: .collection(kind: .typeSpecifierList, collectionElementName: "Specifier", defaultsToEmpty: true)
+        kind: .collection(kind: .typeSpecifierList, collectionElementName: "Specifier", defaultsToEmpty: true),
+        documentation: "A list of specifiers that can be attached to the type, such as `inout`, `isolated`, or `consuming`."
       ),
       Child(
         name: "attributes",
-        kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true)
+        kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true),
+        documentation: "A list of attributes that can be attached to the type, such as `@escaping`."
       ),
       Child(
         name: "baseType",
-        kind: .node(kind: .type)
+        kind: .node(kind: .type),
+        documentation: "The type to with the specifiers and attributes are applied."
       ),
     ]
   ),
@@ -522,4 +495,34 @@ public let TYPE_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .typeSpecifier,
+    base: .syntax,
+    nameForDiagnostics: nil,
+    documentation: "A specifier that can be attached to a type to eg. mark a parameter as `inout` or `consuming`",
+    children: [
+      Child(
+        name: "specifier",
+        kind: .token(choices: [
+          .keyword(.inout),
+          .keyword(.__shared),
+          .keyword(.__owned),
+          .keyword(.isolated),
+          .keyword(._const),
+          .keyword(.borrowing),
+          .keyword(.consuming),
+          .keyword(.transferring),
+          .keyword(._resultDependsOn),
+        ]),
+        documentation: "The specifier token that's attached to the type."
+      )
+    ]
+  ),
+
+  Node(
+    kind: .typeSpecifierList,
+    base: .syntaxCollection,
+    nameForDiagnostics: nil,
+    elementChoices: [.typeSpecifier]
+  ),
 ]

CodeGeneration/Sources/generate-swift-syntax/templates/swiftparser/ParserTokenSpecSetFile.swift

@@ -83,6 +83,17 @@ let parserTokenSpecSetFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
               }
             }
 
+            try InitializerDeclSyntax("public init?(token: TokenSyntax)") {
+              try SwitchExprSyntax("switch token") {
+                for choice in choices {
+                  SwitchCaseSyntax(
+                    "case TokenSpec(.\(choice.varOrCaseName)): self = .\(choice.varOrCaseName)"
+                  )
+                }
+                SwitchCaseSyntax("default: return nil")
+              }
+            }
+
             try VariableDeclSyntax("var spec: TokenSpec") {
               try SwitchExprSyntax("switch self") {
                 for choice in choices {

Sources/SwiftParser/Parameters.swift

@@ -261,7 +261,7 @@ extension Parser {
   mutating func parseMisplacedSpecifiers() -> [RawTokenSyntax] {
     var misplacedSpecifiers: [RawTokenSyntax] = []
     if self.withLookahead({ !$0.startsParameterName(isClosure: false, allowMisplacedSpecifierRecovery: false) }) {
-      while canHaveParameterSpecifier, let specifier = self.consume(ifAnyIn: TypeSpecifier.self) {
+      while canHaveParameterSpecifier, let specifier = self.consume(ifAnyIn: TypeSpecifierSyntax.SpecifierOptions.self) {
         misplacedSpecifiers.append(specifier)
       }
     }

Sources/SwiftParser/Patterns.swift

@@ -340,7 +340,7 @@ extension Parser.Lookahead {
   mutating func startsParameterName(isClosure: Bool, allowMisplacedSpecifierRecovery: Bool) -> Bool {
     if allowMisplacedSpecifierRecovery {
       while canHaveParameterSpecifier,
-        self.consume(ifAnyIn: TypeSpecifier.self) != nil
+        self.consume(ifAnyIn: TypeSpecifierSyntax.SpecifierOptions.self) != nil
       {}
     }
 

Sources/SwiftParser/TokenSpecSet.swift

@@ -691,52 +691,6 @@ enum TypeAttribute: TokenSpecSet {
   }
 }
 
-@_spi(Diagnostics)
-public enum TypeSpecifier: TokenSpecSet {
-  case `inout`
-  case owned
-  case shared
-  case borrowing
-  case consuming
-  case transferring
-
-  init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
-    switch PrepareForKeywordMatch(lexeme) {
-    case TokenSpec(.inout): self = .inout
-    case TokenSpec(.__owned): self = .owned
-    case TokenSpec(.__shared): self = .shared
-    case TokenSpec(.consuming): self = .consuming
-    case TokenSpec(.borrowing): self = .borrowing
-    case TokenSpec(.transferring): self = .transferring
-    default: return nil
-    }
-  }
-
-  @_spi(Diagnostics)
-  public init?(token: TokenSyntax) {
-    switch token {
-    case TokenSpec(.inout): self = .inout
-    case TokenSpec(.__owned): self = .owned
-    case TokenSpec(.__shared): self = .shared
-    case TokenSpec(.consuming): self = .shared
-    case TokenSpec(.borrowing): self = .shared
-    case TokenSpec(.transferring): self = .transferring
-    default: return nil
-    }
-  }
-
-  var spec: TokenSpec {
-    switch self {
-    case .inout: return .keyword(.inout)
-    case .owned: return .keyword(.__owned)
-    case .shared: return .keyword(.__shared)
-    case .borrowing: return .keyword(.borrowing)
-    case .consuming: return .keyword(.consuming)
-    case .transferring: return .keyword(.transferring)
-    }
-  }
-}
-
 // MARK: Expression start
 
 enum ExpressionModifierKeyword: TokenSpecSet {

Sources/SwiftParser/Types.swift

@@ -468,7 +468,7 @@ extension Parser {
         var misplacedSpecifiers: [RawTokenSyntax] = []
         if self.withLookahead({ $0.startsParameterName(isClosure: false, allowMisplacedSpecifierRecovery: true) }) {
           while canHaveParameterSpecifier,
-            let specifier = self.consume(ifAnyIn: TypeSpecifier.self)
+            let specifier = self.consume(ifAnyIn: TypeSpecifierSyntax.SpecifierOptions.self)
           {
             misplacedSpecifiers.append(specifier)
           }
@@ -623,7 +623,7 @@ extension Parser.Lookahead {
     var specifierProgress = LoopProgressCondition()
     // TODO: Can we model isolated/_const so that they're specified in both canParse* and parse*?
     while canHaveParameterSpecifier,
-      self.at(anyIn: TypeSpecifier.self) != nil || self.at(.keyword(.isolated)) || self.at(.keyword(._const)),
+      self.at(anyIn: TypeSpecifierSyntax.SpecifierOptions.self) != nil || self.at(.keyword(.isolated)) || self.at(.keyword(._const)),
       self.hasProgressed(&specifierProgress)
     {
       self.consumeAnyToken()