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/generate-swift-syntax/templates/swiftparser/ParserTokenSpecSetFile.swift

@@ -70,6 +70,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

@@ -326,7 +326,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

@@ -684,52 +684,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

@@ -457,7 +457,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)
           }
@@ -612,7 +612,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()