[NFC] Refactor DeclarationKeyword

It actually ought to be the union of three token kind subsets; turn it into a custom type so we can do that.

Author: beccadax

Sources/SwiftParser/Declarations.swift

@@ -110,7 +110,7 @@ extension TokenConsumer {
       declStartKeyword = subparser.at(anyIn: DeclarationKeyword.self)?.0
     }
     switch declStartKeyword {
-    case .lhs(.actor):
+    case .group(.actor):
       // actor Foo {}
       if subparser.peek().rawTokenKind == .identifier {
         return true
@@ -123,16 +123,16 @@ extension TokenConsumer {
         lookahead.consumeAnyToken()
       } while lookahead.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl)
       return lookahead.at(.identifier)
-    case .lhs(.case):
+    case .simple(.case):
       // When 'case' appears inside a function, it's probably a switch
       // case, not an enum case declaration.
       return false
-    case .lhs(.`init`):
+    case .simple(.`init`):
       return allowInitDecl
-    case .lhs(.macro):
+    case .simple(.macro):
       // macro Foo ...
       return subparser.peek().rawTokenKind == .identifier
-    case .lhs(.pound):
+    case .simple(.pound):
       // Force parsing '#<identifier>' after attributes as a macro expansion decl.
       if hasAttribute || hasModifier {
         return true
@@ -215,7 +215,7 @@ extension Parser {
     } else if atFunctionDeclarationWithoutFuncKeyword() {
       // We aren't at a declaration keyword and it looks like we are at a function
       // declaration. Parse a function declaration.
-      recoveryResult = (.lhs(.func), .missing(.keyword(.func)))
+      recoveryResult = (.simple(.func), .missing(.keyword(.func)))
     } else {
       // In all other cases, use standard token recovery to find the declaration
       // to parse.
@@ -226,53 +226,53 @@ extension Parser {
     }
 
     switch recoveryResult {
-    case (.lhs(.import), let handle)?:
+    case (.simple(.import), let handle)?:
       return RawDeclSyntax(self.parseImportDeclaration(attrs, handle))
-    case (.lhs(.class), let handle)?:
+    case (.group(.class), let handle)?:
       return RawDeclSyntax(
         self.parseNominalTypeDeclaration(for: RawClassDeclSyntax.self, attrs: attrs, introucerHandle: handle)
       )
-    case (.lhs(.enum), let handle)?:
+    case (.group(.enum), let handle)?:
       return RawDeclSyntax(
         self.parseNominalTypeDeclaration(for: RawEnumDeclSyntax.self, attrs: attrs, introucerHandle: handle)
       )
-    case (.lhs(.case), let handle)?:
+    case (.simple(.case), let handle)?:
       return RawDeclSyntax(self.parseEnumCaseDeclaration(attrs, handle))
-    case (.lhs(.struct), let handle)?:
+    case (.group(.struct), let handle)?:
       return RawDeclSyntax(
         self.parseNominalTypeDeclaration(for: RawStructDeclSyntax.self, attrs: attrs, introucerHandle: handle)
       )
-    case (.lhs(.protocol), let handle)?:
+    case (.group(.protocol), let handle)?:
       return RawDeclSyntax(
         self.parseNominalTypeDeclaration(for: RawProtocolDeclSyntax.self, attrs: attrs, introucerHandle: handle)
       )
-    case (.lhs(.associatedtype), let handle)?:
+    case (.simple(.associatedtype), let handle)?:
       return RawDeclSyntax(self.parseAssociatedTypeDeclaration(attrs, handle))
-    case (.lhs(.typealias), let handle)?:
+    case (.simple(.typealias), let handle)?:
       return RawDeclSyntax(self.parseTypealiasDeclaration(attrs, handle))
-    case (.lhs(.extension), let handle)?:
+    case (.group(.extension), let handle)?:
       return RawDeclSyntax(self.parseExtensionDeclaration(attrs, handle))
-    case (.lhs(.func), let handle)?:
+    case (.simple(.func), let handle)?:
       return RawDeclSyntax(self.parseFuncDeclaration(attrs, handle))
-    case (.lhs(.subscript), let handle)?:
+    case (.simple(.subscript), let handle)?:
       return RawDeclSyntax(self.parseSubscriptDeclaration(attrs, handle))
-    case (.lhs(.`init`), let handle)?:
+    case (.simple(.`init`), let handle)?:
       return RawDeclSyntax(self.parseInitializerDeclaration(attrs, handle))
-    case (.lhs(.deinit), let handle)?:
+    case (.simple(.deinit), let handle)?:
       return RawDeclSyntax(self.parseDeinitializerDeclaration(attrs, handle))
-    case (.lhs(.operator), let handle)?:
+    case (.simple(.operator), let handle)?:
       return RawDeclSyntax(self.parseOperatorDeclaration(attrs, handle))
-    case (.lhs(.precedencegroup), let handle)?:
+    case (.simple(.precedencegroup), let handle)?:
       return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle))
-    case (.lhs(.actor), let handle)?:
+    case (.group(.actor), let handle)?:
       return RawDeclSyntax(
         self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle)
       )
-    case (.lhs(.macro), let handle)?:
+    case (.simple(.macro), let handle)?:
       return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle))
-    case (.lhs(.pound), let handle)?:
+    case (.simple(.pound), let handle)?:
       return RawDeclSyntax(self.parseMacroExpansionDeclaration(attrs, handle))
-    case (.rhs, let handle)?:
+    case (.binding, let handle)?:
       return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, inMemberDeclList: inMemberDeclList))
     case nil:
       break

Sources/SwiftParser/TokenSpecSet.swift

@@ -267,82 +267,105 @@ enum ContextualDeclKeyword: TokenSpecSet {
   }
 }
 
-/// A `DeclarationKeyword` that is not a `ValueBindingPatternSyntax.BindingSpecifierOptions`.
-///
-/// `ValueBindingPatternSyntax.BindingSpecifierOptions` are injected into
-/// `DeclarationKeyword` via an `EitherTokenSpecSet`.
-enum PureDeclarationKeyword: TokenSpecSet {
-  case actor
-  case `associatedtype`
-  case `case`
-  case `class`
-  case `deinit`
-  case `enum`
-  case `extension`
-  case `func`
-  case `import`
-  case `init`
-  case macro
-  case `operator`
-  case `precedencegroup`
-  case `protocol`
-  case `struct`
-  case `subscript`
-  case `typealias`
-  case pound
+/// Union of the following token kind subsets:
+///  - `ValueBindingPatternSyntax.BindingSpecifierOptions`
+///  - `DeclGroupHeaderSyntax.IntroducerOptions`
+///  - `DeclarationKeyword.Simple` (containing other declaration keywords)
+enum DeclarationKeyword: TokenSpecSet {
+  /// A keyword introducing a binding declaration (a declaration which binds patterns to values).
+  case binding(Binding)
+
+  /// A keyword introducing a declaration group (a declaration with a member block).
+  case group(Group)
+
+  /// A keyword introducing a simple declaration (a declaration which is neither a group nor a binding).
+  case simple(Simple)
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
-    switch PrepareForKeywordMatch(lexeme) {
-    case TokenSpec(.actor): self = .actor
-    case TokenSpec(.macro): self = .macro
-    case TokenSpec(.associatedtype): self = .associatedtype
-    case TokenSpec(.case): self = .case
-    case TokenSpec(.class): self = .class
-    case TokenSpec(.deinit): self = .deinit
-    case TokenSpec(.enum): self = .enum
-    case TokenSpec(.extension): self = .extension
-    case TokenSpec(.func): self = .func
-    case TokenSpec(.import): self = .import
-    case TokenSpec(.`init`): self = .`init`
-    case TokenSpec(.operator): self = .operator
-    case TokenSpec(.precedencegroup): self = .precedencegroup
-    case TokenSpec(.protocol): self = .protocol
-    case TokenSpec(.struct): self = .struct
-    case TokenSpec(.subscript): self = .subscript
-    case TokenSpec(.typealias): self = .typealias
-    case TokenSpec(.pound): self = .pound
-    default: return nil
+    if let simple = Simple(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .simple(simple)
+    }
+    else if let group = DeclGroupHeaderSyntax.IntroducerOptions(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .group(group)
+    }
+    else if let binding = ValueBindingPatternSyntax.BindingSpecifierOptions(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .binding(binding)
+    }
+    else {
+      return nil
     }
   }
 
   var spec: TokenSpec {
     switch self {
-    case .actor: return TokenSpec(.actor, recoveryPrecedence: .declKeyword)
-    case .associatedtype: return .keyword(.associatedtype)
-    case .case: return TokenSpec(.case, recoveryPrecedence: .declKeyword)
-    case .class: return .keyword(.class)
-    case .deinit: return .keyword(.deinit)
-    case .enum: return .keyword(.enum)
-    case .extension: return .keyword(.extension)
-    case .func: return .keyword(.func)
-    case .import: return .keyword(.import)
-    case .`init`: return .keyword(.`init`)
-    case .macro: return TokenSpec(.macro, recoveryPrecedence: .declKeyword)
-    case .operator: return .keyword(.operator)
-    case .precedencegroup: return .keyword(.precedencegroup)
-    case .protocol: return .keyword(.protocol)
-    case .struct: return .keyword(.struct)
-    case .subscript: return .keyword(.subscript)
-    case .typealias: return .keyword(.typealias)
-    case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
+    case .simple(let simple): return simple.spec
+    case .group(let group): return group.spec
+    case .binding(let binding): return binding.spec
+    }
+  }
+
+  static let allCases: [DeclarationKeyword] = Binding.allCases.map { .binding($0) } + Group.allCases.map { .group($0) } + Simple.allCases.map { .simple($0) }
+}
+
+extension DeclarationKeyword {
+  /// Type for a keyword introducing a binding declaration (a declaration which binds patterns to values).
+  typealias Binding = ValueBindingPatternSyntax.BindingSpecifierOptions
+
+  /// Type for a keyword introducing a declaration group (a declaration with a member block).
+  typealias Group = DeclGroupHeaderSyntax.IntroducerOptions
+
+  /// Type for a keyword introducing a simple declaration (a declaration which is neither a group nor a binding).
+  enum Simple: TokenSpecSet {
+    case `associatedtype`
+    case `case`
+    case `deinit`
+    case `func`
+    case `import`
+    case `init`
+    case macro
+    case `operator`
+    case `precedencegroup`
+    case `subscript`
+    case `typealias`
+    case pound
+
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.macro): self = .macro
+      case TokenSpec(.associatedtype): self = .associatedtype
+      case TokenSpec(.case): self = .case
+      case TokenSpec(.deinit): self = .deinit
+      case TokenSpec(.func): self = .func
+      case TokenSpec(.import): self = .import
+      case TokenSpec(.`init`): self = .`init`
+      case TokenSpec(.operator): self = .operator
+      case TokenSpec(.precedencegroup): self = .precedencegroup
+      case TokenSpec(.subscript): self = .subscript
+      case TokenSpec(.typealias): self = .typealias
+      case TokenSpec(.pound): self = .pound
+      default: return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case .associatedtype: return .keyword(.associatedtype)
+      case .case: return TokenSpec(.case, recoveryPrecedence: .declKeyword)
+      case .deinit: return .keyword(.deinit)
+      case .func: return .keyword(.func)
+      case .import: return .keyword(.import)
+      case .`init`: return .keyword(.`init`)
+      case .macro: return TokenSpec(.macro, recoveryPrecedence: .declKeyword)
+      case .operator: return .keyword(.operator)
+      case .precedencegroup: return .keyword(.precedencegroup)
+      case .subscript: return .keyword(.subscript)
+      case .typealias: return .keyword(.typealias)
+      case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
+      }
     }
   }
 }
 
-typealias DeclarationKeyword = EitherTokenSpecSet<
-  PureDeclarationKeyword,
-  ValueBindingPatternSyntax.BindingSpecifierOptions
->
 
 enum DeclarationModifier: TokenSpecSet {
   case __consuming