diff --git a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift index db71bb32058..dba9fd776c8 100644 --- a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift @@ -534,7 +534,6 @@ public let DECL_NODES: [Node] = [ .keyword(text: "public"), .keyword(text: "reasync"), .keyword(text: "required"), - .keyword(text: "setter_access"), .keyword(text: "static"), .keyword(text: "unowned"), .keyword(text: "weak"), diff --git a/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift b/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift index 474d95239eb..7800fc7e35d 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift @@ -89,6 +89,7 @@ struct GenerateSwiftSyntax: ParsableCommand { // SwiftParser GeneratedFileSpec(swiftParserGeneratedDir + ["IsLexerClassified.swift"], isLexerClassifiedFile), GeneratedFileSpec(swiftParserGeneratedDir + ["Parser+Entry.swift"], parserEntryFile), + GeneratedFileSpec(swiftParserGeneratedDir + ["Parser+TokenSpecSet.swift"], parserTokenSpecSetFile), GeneratedFileSpec(swiftParserGeneratedDir + ["TokenSpecStaticMembers.swift"], tokenSpecStaticMembersFile), // SwiftParserDiagnostics diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserTokenSpecSetFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserTokenSpecSetFile.swift new file mode 100644 index 00000000000..09e20eba517 --- /dev/null +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserTokenSpecSetFile.swift @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax +import SwiftSyntaxBuilder +import SyntaxSupport +import Utils + +let parserTokenSpecSetFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { + DeclSyntax("@_spi(RawSyntax) import SwiftSyntax") + + for layoutNode in SYNTAX_NODES.compactMap(\.layoutNode) { + for child in layoutNode.children { + if case let .token(choices, _, _) = child.kind, choices.count > 1 { + try! ExtensionDeclSyntax("extension \(raw: layoutNode.kind.syntaxType)") { + try EnumDeclSyntax("enum \(raw: child.name)Options: TokenSpecSet") { + for choice in choices { + switch choice { + case .keyword(let keywordText): + let keyword = KEYWORDS.first(where: { $0.name == keywordText })! + DeclSyntax("case \(raw: keyword.escapedName)") + case .token(let tokenText): + let token = SYNTAX_TOKEN_MAP[tokenText]! + DeclSyntax("case \(raw: token.swiftKind)") + } + } + + try InitializerDeclSyntax("init?(lexeme: Lexer.Lexeme)") { + try SwitchExprSyntax("switch PrepareForKeywordMatch(lexeme)") { + for choice in choices { + switch choice { + case .keyword(let keywordText): + let keyword = KEYWORDS.first(where: { $0.name == keywordText })! + SwitchCaseSyntax("case TokenSpec(.\(raw: keyword.escapedName)): self = .\(raw: keyword.escapedName)") + case .token(let tokenText): + let token = SYNTAX_TOKEN_MAP[tokenText]! + SwitchCaseSyntax( + "case TokenSpec(.\(raw: token.swiftKind)): self = .\(raw: token.swiftKind)" + ) + } + } + SwitchCaseSyntax("default: return nil") + } + } + + try VariableDeclSyntax("var spec: TokenSpec") { + try SwitchExprSyntax("switch self") { + for choice in choices { + switch choice { + case .keyword(let keywordText): + let keyword = KEYWORDS.first(where: { $0.name == keywordText })! + SwitchCaseSyntax( + "case .\(raw: keyword.escapedName): return .keyword(.\(raw: keyword.escapedName))" + ) + case .token(let tokenText): + let token = SYNTAX_TOKEN_MAP[tokenText]! + SwitchCaseSyntax( + "case .\(raw: token.swiftKind): return .\(raw: token.swiftKind)" + ) + } + } + } + } + } + } + } + } + } +} diff --git a/Sources/SwiftParser/Attributes.swift b/Sources/SwiftParser/Attributes.swift index 8d3be90d02d..e9575b9fb3d 100644 --- a/Sources/SwiftParser/Attributes.swift +++ b/Sources/SwiftParser/Attributes.swift @@ -363,33 +363,10 @@ extension Parser { ) } - enum DifferentiabilityKind: TokenSpecSet { - case reverse - case _linear - case _forward - - init?(lexeme: Lexer.Lexeme) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(.reverse): self = .reverse - case TokenSpec(._linear): self = ._linear - case TokenSpec(._forward): self = ._forward - default: return nil - } - } - - var spec: TokenSpec { - switch self { - case .reverse: return .keyword(.reverse) - case ._linear: return .keyword(._linear) - case ._forward: return .keyword(._forward) - } - } - } - mutating func parseDifferentiableAttributeArguments() -> RawDifferentiableAttributeArgumentsSyntax { let diffKind: RawTokenSyntax? let diffKindComma: RawTokenSyntax? - if let (_, handle) = self.at(anyIn: DifferentiabilityKind.self) { + if let (_, handle) = self.at(anyIn: DifferentiableAttributeArgumentsSyntax.DiffKindOptions.self) { diffKind = self.eat(handle) diffKindComma = self.consume(if: .comma) } else { @@ -474,30 +451,7 @@ extension Parser { } mutating func parseDifferentiabilityParameter() -> RawDifferentiabilityParamSyntax? { - enum ExpectedTokenKind: TokenSpecSet { - case identifier - case integerLiteral - case `self` - - init?(lexeme: Lexer.Lexeme) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(.identifier): self = .identifier - case TokenSpec(.integerLiteral): self = .integerLiteral - case TokenSpec(.self): self = .self - default: return nil - } - } - - var spec: TokenSpec { - switch self { - case .identifier: return .identifier - case .integerLiteral: return .integerLiteral - case .self: return .keyword(.self) - } - } - } - - switch self.at(anyIn: ExpectedTokenKind.self) { + switch self.at(anyIn: DifferentiabilityParamSyntax.ParameterOptions.self) { case (.identifier, let handle)?: let token = self.eat(handle) let comma = self.consume(if: .comma) diff --git a/Sources/SwiftParser/CMakeLists.txt b/Sources/SwiftParser/CMakeLists.txt index 47639e8045b..daa969ccbaf 100644 --- a/Sources/SwiftParser/CMakeLists.txt +++ b/Sources/SwiftParser/CMakeLists.txt @@ -38,6 +38,7 @@ add_swift_host_library(SwiftParser generated/IsLexerClassified.swift generated/Parser+Entry.swift + generated/Parser+TokenSpecSet.swift generated/TokenSpecStaticMembers.swift Lexer/Cursor.swift diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index 545810e2ff0..9f996200d3a 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -339,48 +339,7 @@ extension Parser { } mutating func parseImportKind() -> RawTokenSyntax? { - enum ImportKind: TokenSpecSet { - case `typealias` - case `struct` - case `class` - case `enum` - case `protocol` - case `var` - case `let` - case `func` - case `inout` - - var spec: TokenSpec { - switch self { - case .typealias: return .keyword(.typealias) - case .struct: return .keyword(.struct) - case .class: return .keyword(.class) - case .enum: return .keyword(.enum) - case .protocol: return .keyword(.protocol) - case .var: return .keyword(.var) - case .let: return .keyword(.let) - case .func: return .keyword(.func) - case .inout: return .keyword(.inout) - } - } - - init?(lexeme: Lexer.Lexeme) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(.typealias): self = .typealias - case TokenSpec(.struct): self = .struct - case TokenSpec(.class): self = .class - case TokenSpec(.enum): self = .enum - case TokenSpec(.protocol): self = .protocol - case TokenSpec(.var): self = .var - case TokenSpec(.let): self = .let - case TokenSpec(.func): self = .func - case TokenSpec(.inout): self = .inout - default: return nil - } - } - } - - return self.consume(ifAnyIn: ImportKind.self) + return self.consume(ifAnyIn: ImportDeclSyntax.ImportKindOptions.self) } mutating func parseImportPath() -> RawImportPathSyntax { @@ -581,56 +540,6 @@ extension Parser { ) } - enum LayoutConstraint: TokenSpecSet { - case _Trivial - case _TrivialAtMost - case _UnknownLayout - case _RefCountedObjectLayout - case _NativeRefCountedObjectLayout - case _Class - case _NativeClass - - init?(lexeme: Lexer.Lexeme) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(._Trivial): self = ._Trivial - case TokenSpec(._TrivialAtMost): self = ._TrivialAtMost - case TokenSpec(._UnknownLayout): self = ._UnknownLayout - case TokenSpec(._RefCountedObject): self = ._RefCountedObjectLayout - case TokenSpec(._NativeRefCountedObject): self = ._NativeRefCountedObjectLayout - case TokenSpec(._Class): self = ._Class - case TokenSpec(._NativeClass): self = ._NativeClass - default: return nil - } - } - - var spec: TokenSpec { - switch self { - case ._Trivial: return .keyword(._Trivial) - case ._TrivialAtMost: return .keyword(._TrivialAtMost) - case ._UnknownLayout: return .keyword(._UnknownLayout) - case ._RefCountedObjectLayout: return .keyword(._RefCountedObject) - case ._NativeRefCountedObjectLayout: return .keyword(._NativeRefCountedObject) - case ._Class: return .keyword(._Class) - case ._NativeClass: return .keyword(._NativeClass) - } - } - - var hasArguments: Bool { - switch self { - case ._Trivial, - ._TrivialAtMost: - return true - - case ._UnknownLayout, - ._RefCountedObjectLayout, - ._NativeRefCountedObjectLayout, - ._Class, - ._NativeClass: - return false - } - } - } - mutating func parseGenericWhereClause() -> RawGenericWhereClauseSyntax { let (unexpectedBeforeWhereKeyword, whereKeyword) = self.expect(.keyword(.where)) @@ -690,7 +599,7 @@ extension Parser { case (.colon, let handle)?: let colon = self.eat(handle) // A conformance-requirement. - if let (layoutConstraint, handle) = self.at(anyIn: LayoutConstraint.self) { + if let (layoutConstraint, handle) = self.at(anyIn: LayoutRequirementSyntax.LayoutConstraintOptions.self) { // Parse a layout constraint. let constraint = self.eat(handle) @@ -701,9 +610,25 @@ extension Parser { let alignment: RawTokenSyntax? let unexpectedBeforeRightParen: RawUnexpectedNodesSyntax? let rightParen: RawTokenSyntax? + + var hasArguments: Bool { + switch layoutConstraint { + case ._Trivial, + ._TrivialAtMost: + return true + + case ._UnknownLayout, + ._RefCountedObject, + ._NativeRefCountedObject, + ._Class, + ._NativeClass: + return false + } + } + // Unlike the other layout constraints, _Trivial's argument list // is optional. - if layoutConstraint.hasArguments && (layoutConstraint != ._Trivial || self.at(.leftParen)) { + if hasArguments && (layoutConstraint != ._Trivial || self.at(.leftParen)) { (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen) size = self.expectWithoutRecovery(.integerLiteral) comma = self.consume(if: .comma) @@ -1296,7 +1221,7 @@ extension Parser { // Parse getter and setter. let accessor: RawSubscriptDeclSyntax.Accessor? - if self.at(.leftBrace) || self.at(anyIn: AccessorKind.self) != nil { + if self.at(.leftBrace) || self.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) != nil { accessor = self.parseGetSet() } else { accessor = nil @@ -1418,7 +1343,7 @@ extension Parser { } let accessor: RawPatternBindingSyntax.Accessor? - if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorKind.self) != nil && !self.at(.keyword(.`init`))) { + if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) != nil && !self.at(.keyword(.`init`))) { switch self.parseGetSet() { case .accessors(let accessors): accessor = .accessors(accessors) @@ -1456,19 +1381,19 @@ extension Parser { struct AccessorIntroducer { var attributes: RawAttributeListSyntax? var modifier: RawDeclModifierSyntax? - var kind: AccessorKind + var kind: AccessorDeclSyntax.AccessorKindOptions var unexpectedBeforeToken: RawUnexpectedNodesSyntax? var token: RawTokenSyntax } mutating func parseAccessorIntroducer( - forcedKind: (AccessorKind, TokenConsumptionHandle)? = nil + forcedKind: (AccessorDeclSyntax.AccessorKindOptions, TokenConsumptionHandle)? = nil ) -> AccessorIntroducer? { // Check there is an identifier before consuming var look = self.lookahead() let _ = look.consumeAttributeList() let hasModifier = look.consume(if: .keyword(.mutating), .keyword(.nonmutating), .keyword(.__consuming)) != nil - guard let (kind, _) = look.at(anyIn: AccessorKind.self) ?? forcedKind else { + guard let (kind, _) = look.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) ?? forcedKind else { return nil } @@ -1530,7 +1455,7 @@ extension Parser { // // set-name ::= '(' identifier ')' let parameter: RawAccessorParameterSyntax? - if [AccessorKind.set, .willSet, .didSet, .`init`].contains(introducer.kind), let lparen = self.consume(if: .leftParen) { + if [AccessorDeclSyntax.AccessorKindOptions.set, .willSet, .didSet, .`init`].contains(introducer.kind), let lparen = self.consume(if: .leftParen) { let (unexpectedBeforeName, name) = self.expectIdentifier() let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen) parameter = RawAccessorParameterSyntax( @@ -1575,7 +1500,7 @@ extension Parser { // Parse getter and setter. let unexpectedBeforeLBrace: RawUnexpectedNodesSyntax? let lbrace: RawTokenSyntax - if self.at(anyIn: AccessorKind.self) != nil { + if self.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) != nil { unexpectedBeforeLBrace = nil lbrace = missingToken(.leftBrace) } else { @@ -1976,7 +1901,7 @@ extension Parser { case (.assignment, let handle)?: let assignmentKeyword = self.eat(handle) let (unexpectedBeforeColon, colon) = self.expect(.colon) - let (unexpectedBeforeFlag, flag) = self.expect(.keyword(.true), .keyword(.false), default: .keyword(.true)) + let (unexpectedBeforeFlag, flag) = self.expect(anyIn: PrecedenceGroupAssignmentSyntax.FlagOptions.self, default: .true) let unexpectedAfterFlag: RawUnexpectedNodesSyntax? if flag.isMissing, let unexpectedIdentifier = self.consume(if: TokenSpec(.identifier, allowAtStartOfLine: false)) { unexpectedAfterFlag = RawUnexpectedNodesSyntax([unexpectedIdentifier], arena: self.arena) diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift index 7e3246cbb5b..846e2bffee3 100644 --- a/Sources/SwiftParser/Expressions.swift +++ b/Sources/SwiftParser/Expressions.swift @@ -2620,7 +2620,7 @@ extension Parser { var versionInfo: RawCanImportVersionInfoSyntax? if let comma = self.consume(if: .comma) { - let (unexpectedBeforeLabel, label) = self.expect(.keyword(._version), .keyword(._underlyingVersion), default: .keyword(._version)) + let (unexpectedBeforeLabel, label) = self.expect(anyIn: CanImportVersionInfoSyntax.LabelOptions.self, default: ._version) let (unexpectedBeforeColon, colon) = self.expect(.colon) let version = self.parseVersionTuple(maxComponentCount: 4) diff --git a/Sources/SwiftParser/TokenSpecSet.swift b/Sources/SwiftParser/TokenSpecSet.swift index f2afa14dd9c..4881bcd9a17 100644 --- a/Sources/SwiftParser/TokenSpecSet.swift +++ b/Sources/SwiftParser/TokenSpecSet.swift @@ -23,59 +23,6 @@ protocol TokenSpecSet: CaseIterable { // MARK: - Subsets -enum AccessorKind: TokenSpecSet { - case `get` - case `set` - case `didSet` - case `willSet` - case `init` - case unsafeAddress - case addressWithOwner - case addressWithNativeOwner - case unsafeMutableAddress - case mutableAddressWithOwner - case mutableAddressWithNativeOwner - case _read - case _modify - - init?(lexeme: Lexer.Lexeme) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(.get): self = .get - case TokenSpec(.set): self = .set - case TokenSpec(.didSet): self = .didSet - case TokenSpec(.willSet): self = .willSet - case TokenSpec(.`init`): self = .`init` - case TokenSpec(.unsafeAddress): self = .unsafeAddress - case TokenSpec(.addressWithOwner): self = .addressWithOwner - case TokenSpec(.addressWithNativeOwner): self = .addressWithNativeOwner - case TokenSpec(.unsafeMutableAddress): self = .unsafeMutableAddress - case TokenSpec(.mutableAddressWithOwner): self = .mutableAddressWithOwner - case TokenSpec(.mutableAddressWithNativeOwner): self = .mutableAddressWithNativeOwner - case TokenSpec(._read): self = ._read - case TokenSpec(._modify): self = ._modify - default: return nil - } - } - - var spec: TokenSpec { - switch self { - case .get: return .keyword(.get) - case .set: return .keyword(.set) - case .didSet: return .keyword(.didSet) - case .willSet: return .keyword(.willSet) - case .`init`: return .keyword(.`init`) - case .unsafeAddress: return .keyword(.unsafeAddress) - case .addressWithOwner: return .keyword(.addressWithOwner) - case .addressWithNativeOwner: return .keyword(.addressWithNativeOwner) - case .unsafeMutableAddress: return .keyword(.unsafeMutableAddress) - case .mutableAddressWithOwner: return .keyword(.mutableAddressWithOwner) - case .mutableAddressWithNativeOwner: return .keyword(.mutableAddressWithNativeOwner) - case ._read: return .keyword(._read) - case ._modify: return .keyword(._modify) - } - } -} - enum CanBeStatementStart: TokenSpecSet { case _forget // NOTE: support for deprecated _forget case `break` diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index e27c8b7afad..e226092f88d 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -944,43 +944,8 @@ extension Parser { } var extraneousSpecifiers: [RawTokenSyntax] = [] - enum ExtraneousSpecifier: TokenSpecSet { - case `inout` - case __shared - case __owned - case isolated - case _const - case consuming - case borrowing - - var spec: TokenSpec { - switch self { - case .inout: return .keyword(.inout) - case .__shared: return .keyword(.__shared) - case .__owned: return .keyword(.__owned) - case .isolated: return .keyword(.isolated) - case ._const: return .keyword(._const) - case .consuming: return .keyword(.consuming) - case .borrowing: return .keyword(.borrowing) - } - } - - init?(lexeme: Lexer.Lexeme) { - switch PrepareForKeywordMatch(lexeme) { - case TokenSpec(.inout): self = .inout - case TokenSpec(.__shared): self = .__shared - case TokenSpec(.__owned): self = .__owned - case TokenSpec(.isolated): self = .isolated - case TokenSpec(._const): self = ._const - case TokenSpec(.consuming): self = .consuming - case TokenSpec(.borrowing): self = .borrowing - default: return nil - } - } - } - while canHaveParameterSpecifier, - let extraSpecifier = self.consume(ifAnyIn: ExtraneousSpecifier.self) + let extraSpecifier = self.consume(ifAnyIn: AttributedTypeSyntax.SpecifierOptions.self) { if specifier == nil { specifier = extraSpecifier diff --git a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift new file mode 100644 index 00000000000..a29d483bbb2 --- /dev/null +++ b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift @@ -0,0 +1,2086 @@ +//// Automatically generated by generate-swiftsyntax +//// Do not edit directly! +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +@_spi(RawSyntax) import SwiftSyntax + +extension AccessorDeclSyntax { + enum AccessorKindOptions: TokenSpecSet { + case get + case set + case didSet + case willSet + case unsafeAddress + case addressWithOwner + case addressWithNativeOwner + case unsafeMutableAddress + case mutableAddressWithOwner + case mutableAddressWithNativeOwner + case _read + case _modify + case `init` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.get): + self = .get + case TokenSpec(.set): + self = .set + case TokenSpec(.didSet): + self = .didSet + case TokenSpec(.willSet): + self = .willSet + case TokenSpec(.unsafeAddress): + self = .unsafeAddress + case TokenSpec(.addressWithOwner): + self = .addressWithOwner + case TokenSpec(.addressWithNativeOwner): + self = .addressWithNativeOwner + case TokenSpec(.unsafeMutableAddress): + self = .unsafeMutableAddress + case TokenSpec(.mutableAddressWithOwner): + self = .mutableAddressWithOwner + case TokenSpec(.mutableAddressWithNativeOwner): + self = .mutableAddressWithNativeOwner + case TokenSpec(._read): + self = ._read + case TokenSpec(._modify): + self = ._modify + case TokenSpec(.`init`): + self = .`init` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .get: + return .keyword(.get) + case .set: + return .keyword(.set) + case .didSet: + return .keyword(.didSet) + case .willSet: + return .keyword(.willSet) + case .unsafeAddress: + return .keyword(.unsafeAddress) + case .addressWithOwner: + return .keyword(.addressWithOwner) + case .addressWithNativeOwner: + return .keyword(.addressWithNativeOwner) + case .unsafeMutableAddress: + return .keyword(.unsafeMutableAddress) + case .mutableAddressWithOwner: + return .keyword(.mutableAddressWithOwner) + case .mutableAddressWithNativeOwner: + return .keyword(.mutableAddressWithNativeOwner) + case ._read: + return .keyword(._read) + case ._modify: + return .keyword(._modify) + case .`init`: + return .keyword(.`init`) + } + } + } +} + +extension AsExprSyntax { + enum QuestionOrExclamationMarkOptions: TokenSpecSet { + case postfixQuestionMark + case exclamationMark + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.postfixQuestionMark): + self = .postfixQuestionMark + case TokenSpec(.exclamationMark): + self = .exclamationMark + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .postfixQuestionMark: + return .postfixQuestionMark + case .exclamationMark: + return .exclamationMark + } + } + } +} + +extension AttributedTypeSyntax { + enum SpecifierOptions: TokenSpecSet { + case `inout` + case __shared + case __owned + case isolated + case _const + case borrowing + case consuming + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`inout`): + self = .`inout` + case TokenSpec(.__shared): + self = .__shared + case TokenSpec(.__owned): + self = .__owned + case TokenSpec(.isolated): + self = .isolated + case TokenSpec(._const): + self = ._const + case TokenSpec(.borrowing): + self = .borrowing + case TokenSpec(.consuming): + self = .consuming + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`inout`: + return .keyword(.`inout`) + case .__shared: + return .keyword(.__shared) + case .__owned: + return .keyword(.__owned) + case .isolated: + return .keyword(.isolated) + case ._const: + return .keyword(._const) + case .borrowing: + return .keyword(.borrowing) + case .consuming: + return .keyword(.consuming) + } + } + } +} + +extension AvailabilityConditionSyntax { + enum AvailabilityKeywordOptions: TokenSpecSet { + case poundAvailableKeyword + case poundUnavailableKeyword + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.poundAvailableKeyword): + self = .poundAvailableKeyword + case TokenSpec(.poundUnavailableKeyword): + self = .poundUnavailableKeyword + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .poundAvailableKeyword: + return .poundAvailableKeyword + case .poundUnavailableKeyword: + return .poundUnavailableKeyword + } + } + } +} + +extension AvailabilityLabeledArgumentSyntax { + enum LabelOptions: TokenSpecSet { + case message + case renamed + case introduced + case obsoleted + case deprecated + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.message): + self = .message + case TokenSpec(.renamed): + self = .renamed + case TokenSpec(.introduced): + self = .introduced + case TokenSpec(.obsoleted): + self = .obsoleted + case TokenSpec(.deprecated): + self = .deprecated + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .message: + return .keyword(.message) + case .renamed: + return .keyword(.renamed) + case .introduced: + return .keyword(.introduced) + case .obsoleted: + return .keyword(.obsoleted) + case .deprecated: + return .keyword(.deprecated) + } + } + } +} + +extension BooleanLiteralExprSyntax { + enum BooleanLiteralOptions: TokenSpecSet { + case `true` + case `false` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`true`): + self = .`true` + case TokenSpec(.`false`): + self = .`false` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`true`: + return .keyword(.`true`) + case .`false`: + return .keyword(.`false`) + } + } + } +} + +extension CanImportVersionInfoSyntax { + enum LabelOptions: TokenSpecSet { + case _version + case _underlyingVersion + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(._version): + self = ._version + case TokenSpec(._underlyingVersion): + self = ._underlyingVersion + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case ._version: + return .keyword(._version) + case ._underlyingVersion: + return .keyword(._underlyingVersion) + } + } + } +} + +extension ClosureCaptureItemSpecifierSyntax { + enum SpecifierOptions: TokenSpecSet { + case weak + case unowned + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.weak): + self = .weak + case TokenSpec(.unowned): + self = .unowned + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .weak: + return .keyword(.weak) + case .unowned: + return .keyword(.unowned) + } + } + } +} + +extension ClosureCaptureItemSpecifierSyntax { + enum DetailOptions: TokenSpecSet { + case safe + case unsafe + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.safe): + self = .safe + case TokenSpec(.unsafe): + self = .unsafe + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .safe: + return .keyword(.safe) + case .unsafe: + return .keyword(.unsafe) + } + } + } +} + +extension ClosureParamSyntax { + enum NameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension ClosureParameterSyntax { + enum FirstNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension ClosureParameterSyntax { + enum SecondNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension ConstrainedSugarTypeSyntax { + enum SomeOrAnySpecifierOptions: TokenSpecSet { + case some + case any + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.some): + self = .some + case TokenSpec(.any): + self = .any + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .some: + return .keyword(.some) + case .any: + return .keyword(.any) + } + } + } +} + +extension DeclModifierSyntax { + enum NameOptions: TokenSpecSet { + case __consuming + case __setter_access + case _const + case _local + case actor + case async + case borrowing + case `class` + case consuming + case convenience + case distributed + case dynamic + case `fileprivate` + case final + case indirect + case infix + case `internal` + case isolated + case lazy + case mutating + case nonisolated + case nonmutating + case open + case optional + case override + case package + case postfix + case prefix + case `private` + case `public` + case reasync + case required + case `static` + case unowned + case weak + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.__consuming): + self = .__consuming + case TokenSpec(.__setter_access): + self = .__setter_access + case TokenSpec(._const): + self = ._const + case TokenSpec(._local): + self = ._local + case TokenSpec(.actor): + self = .actor + case TokenSpec(.async): + self = .async + case TokenSpec(.borrowing): + self = .borrowing + case TokenSpec(.`class`): + self = .`class` + case TokenSpec(.consuming): + self = .consuming + case TokenSpec(.convenience): + self = .convenience + case TokenSpec(.distributed): + self = .distributed + case TokenSpec(.dynamic): + self = .dynamic + case TokenSpec(.`fileprivate`): + self = .`fileprivate` + case TokenSpec(.final): + self = .final + case TokenSpec(.indirect): + self = .indirect + case TokenSpec(.infix): + self = .infix + case TokenSpec(.`internal`): + self = .`internal` + case TokenSpec(.isolated): + self = .isolated + case TokenSpec(.lazy): + self = .lazy + case TokenSpec(.mutating): + self = .mutating + case TokenSpec(.nonisolated): + self = .nonisolated + case TokenSpec(.nonmutating): + self = .nonmutating + case TokenSpec(.open): + self = .open + case TokenSpec(.optional): + self = .optional + case TokenSpec(.override): + self = .override + case TokenSpec(.package): + self = .package + case TokenSpec(.postfix): + self = .postfix + case TokenSpec(.prefix): + self = .prefix + case TokenSpec(.`private`): + self = .`private` + case TokenSpec(.`public`): + self = .`public` + case TokenSpec(.reasync): + self = .reasync + case TokenSpec(.required): + self = .required + case TokenSpec(.`static`): + self = .`static` + case TokenSpec(.unowned): + self = .unowned + case TokenSpec(.weak): + self = .weak + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .__consuming: + return .keyword(.__consuming) + case .__setter_access: + return .keyword(.__setter_access) + case ._const: + return .keyword(._const) + case ._local: + return .keyword(._local) + case .actor: + return .keyword(.actor) + case .async: + return .keyword(.async) + case .borrowing: + return .keyword(.borrowing) + case .`class`: + return .keyword(.`class`) + case .consuming: + return .keyword(.consuming) + case .convenience: + return .keyword(.convenience) + case .distributed: + return .keyword(.distributed) + case .dynamic: + return .keyword(.dynamic) + case .`fileprivate`: + return .keyword(.`fileprivate`) + case .final: + return .keyword(.final) + case .indirect: + return .keyword(.indirect) + case .infix: + return .keyword(.infix) + case .`internal`: + return .keyword(.`internal`) + case .isolated: + return .keyword(.isolated) + case .lazy: + return .keyword(.lazy) + case .mutating: + return .keyword(.mutating) + case .nonisolated: + return .keyword(.nonisolated) + case .nonmutating: + return .keyword(.nonmutating) + case .open: + return .keyword(.open) + case .optional: + return .keyword(.optional) + case .override: + return .keyword(.override) + case .package: + return .keyword(.package) + case .postfix: + return .keyword(.postfix) + case .prefix: + return .keyword(.prefix) + case .`private`: + return .keyword(.`private`) + case .`public`: + return .keyword(.`public`) + case .reasync: + return .keyword(.reasync) + case .required: + return .keyword(.required) + case .`static`: + return .keyword(.`static`) + case .unowned: + return .keyword(.unowned) + case .weak: + return .keyword(.weak) + } + } + } +} + +extension DeclNameSyntax { + enum DeclBaseNameOptions: TokenSpecSet { + case identifier + case binaryOperator + case `init` + case `self` + case `Self` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.binaryOperator): + self = .binaryOperator + case TokenSpec(.`init`): + self = .`init` + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`Self`): + self = .`Self` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .binaryOperator: + return .binaryOperator + case .`init`: + return .keyword(.`init`) + case .`self`: + return .keyword(.`self`) + case .`Self`: + return .keyword(.`Self`) + } + } + } +} + +extension DerivativeRegistrationAttributeArgumentsSyntax { + enum AccessorKindOptions: TokenSpecSet { + case get + case set + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.get): + self = .get + case TokenSpec(.set): + self = .set + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .get: + return .keyword(.get) + case .set: + return .keyword(.set) + } + } + } +} + +extension DifferentiabilityParamSyntax { + enum ParameterOptions: TokenSpecSet { + case identifier + case integerLiteral + case `self` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.integerLiteral): + self = .integerLiteral + case TokenSpec(.`self`): + self = .`self` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .integerLiteral: + return .integerLiteral + case .`self`: + return .keyword(.`self`) + } + } + } +} + +extension DifferentiableAttributeArgumentsSyntax { + enum DiffKindOptions: TokenSpecSet { + case _forward + case reverse + case _linear + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(._forward): + self = ._forward + case TokenSpec(.reverse): + self = .reverse + case TokenSpec(._linear): + self = ._linear + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case ._forward: + return .keyword(._forward) + case .reverse: + return .keyword(.reverse) + case ._linear: + return .keyword(._linear) + } + } + } +} + +extension DiscardStmtSyntax { + enum DiscardKeywordOptions: TokenSpecSet { + case _forget + case discard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(._forget): + self = ._forget + case TokenSpec(.discard): + self = .discard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case ._forget: + return .keyword(._forget) + case .discard: + return .keyword(.discard) + } + } + } +} + +extension DocumentationAttributeArgumentSyntax { + enum LabelOptions: TokenSpecSet { + case visibility + case metadata + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.visibility): + self = .visibility + case TokenSpec(.metadata): + self = .metadata + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .visibility: + return .keyword(.visibility) + case .metadata: + return .keyword(.metadata) + } + } + } +} + +extension EnumCaseParameterSyntax { + enum FirstNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension EnumCaseParameterSyntax { + enum SecondNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension FunctionDeclSyntax { + enum IdentifierOptions: TokenSpecSet { + case identifier + case binaryOperator + case prefixOperator + case postfixOperator + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.binaryOperator): + self = .binaryOperator + case TokenSpec(.prefixOperator): + self = .prefixOperator + case TokenSpec(.postfixOperator): + self = .postfixOperator + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .binaryOperator: + return .binaryOperator + case .prefixOperator: + return .prefixOperator + case .postfixOperator: + return .postfixOperator + } + } + } +} + +extension FunctionEffectSpecifiersSyntax { + enum AsyncSpecifierOptions: TokenSpecSet { + case async + case reasync + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.async): + self = .async + case TokenSpec(.reasync): + self = .reasync + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .async: + return .keyword(.async) + case .reasync: + return .keyword(.reasync) + } + } + } +} + +extension FunctionEffectSpecifiersSyntax { + enum ThrowsSpecifierOptions: TokenSpecSet { + case `throws` + case `rethrows` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`throws`): + self = .`throws` + case TokenSpec(.`rethrows`): + self = .`rethrows` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`throws`: + return .keyword(.`throws`) + case .`rethrows`: + return .keyword(.`rethrows`) + } + } + } +} + +extension FunctionParameterSyntax { + enum FirstNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension FunctionParameterSyntax { + enum SecondNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension IdentifierExprSyntax { + enum IdentifierOptions: TokenSpecSet { + case identifier + case `self` + case `Self` + case `init` + case dollarIdentifier + case binaryOperator + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`Self`): + self = .`Self` + case TokenSpec(.`init`): + self = .`init` + case TokenSpec(.dollarIdentifier): + self = .dollarIdentifier + case TokenSpec(.binaryOperator): + self = .binaryOperator + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .`self`: + return .keyword(.`self`) + case .`Self`: + return .keyword(.`Self`) + case .`init`: + return .keyword(.`init`) + case .dollarIdentifier: + return .dollarIdentifier + case .binaryOperator: + return .binaryOperator + } + } + } +} + +extension IdentifierPatternSyntax { + enum IdentifierOptions: TokenSpecSet { + case identifier + case `self` + case `init` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`init`): + self = .`init` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .`self`: + return .keyword(.`self`) + case .`init`: + return .keyword(.`init`) + } + } + } +} + +extension IfConfigClauseSyntax { + enum PoundKeywordOptions: TokenSpecSet { + case poundIfKeyword + case poundElseifKeyword + case poundElseKeyword + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.poundIfKeyword): + self = .poundIfKeyword + case TokenSpec(.poundElseifKeyword): + self = .poundElseifKeyword + case TokenSpec(.poundElseKeyword): + self = .poundElseKeyword + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .poundIfKeyword: + return .poundIfKeyword + case .poundElseifKeyword: + return .poundElseifKeyword + case .poundElseKeyword: + return .poundElseKeyword + } + } + } +} + +extension ImportDeclSyntax { + enum ImportKindOptions: TokenSpecSet { + case `typealias` + case `struct` + case `class` + case `enum` + case `protocol` + case `var` + case `let` + case `func` + case `inout` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`typealias`): + self = .`typealias` + case TokenSpec(.`struct`): + self = .`struct` + case TokenSpec(.`class`): + self = .`class` + case TokenSpec(.`enum`): + self = .`enum` + case TokenSpec(.`protocol`): + self = .`protocol` + case TokenSpec(.`var`): + self = .`var` + case TokenSpec(.`let`): + self = .`let` + case TokenSpec(.`func`): + self = .`func` + case TokenSpec(.`inout`): + self = .`inout` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`typealias`: + return .keyword(.`typealias`) + case .`struct`: + return .keyword(.`struct`) + case .`class`: + return .keyword(.`class`) + case .`enum`: + return .keyword(.`enum`) + case .`protocol`: + return .keyword(.`protocol`) + case .`var`: + return .keyword(.`var`) + case .`let`: + return .keyword(.`let`) + case .`func`: + return .keyword(.`func`) + case .`inout`: + return .keyword(.`inout`) + } + } + } +} + +extension ImportPathComponentSyntax { + enum NameOptions: TokenSpecSet { + case identifier + case binaryOperator + case prefixOperator + case postfixOperator + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.binaryOperator): + self = .binaryOperator + case TokenSpec(.prefixOperator): + self = .prefixOperator + case TokenSpec(.postfixOperator): + self = .postfixOperator + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .binaryOperator: + return .binaryOperator + case .prefixOperator: + return .prefixOperator + case .postfixOperator: + return .postfixOperator + } + } + } +} + +extension InitializerDeclSyntax { + enum OptionalMarkOptions: TokenSpecSet { + case postfixQuestionMark + case infixQuestionMark + case exclamationMark + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.postfixQuestionMark): + self = .postfixQuestionMark + case TokenSpec(.infixQuestionMark): + self = .infixQuestionMark + case TokenSpec(.exclamationMark): + self = .exclamationMark + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .postfixQuestionMark: + return .postfixQuestionMark + case .infixQuestionMark: + return .infixQuestionMark + case .exclamationMark: + return .exclamationMark + } + } + } +} + +extension KeyPathOptionalComponentSyntax { + enum QuestionOrExclamationMarkOptions: TokenSpecSet { + case postfixQuestionMark + case exclamationMark + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.postfixQuestionMark): + self = .postfixQuestionMark + case TokenSpec(.exclamationMark): + self = .exclamationMark + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .postfixQuestionMark: + return .postfixQuestionMark + case .exclamationMark: + return .exclamationMark + } + } + } +} + +extension KeyPathPropertyComponentSyntax { + enum IdentifierOptions: TokenSpecSet { + case identifier + case `self` + case `Self` + case `init` + case dollarIdentifier + case binaryOperator + case integerLiteral + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`Self`): + self = .`Self` + case TokenSpec(.`init`): + self = .`init` + case TokenSpec(.dollarIdentifier): + self = .dollarIdentifier + case TokenSpec(.binaryOperator): + self = .binaryOperator + case TokenSpec(.integerLiteral): + self = .integerLiteral + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .`self`: + return .keyword(.`self`) + case .`Self`: + return .keyword(.`Self`) + case .`init`: + return .keyword(.`init`) + case .dollarIdentifier: + return .dollarIdentifier + case .binaryOperator: + return .binaryOperator + case .integerLiteral: + return .integerLiteral + } + } + } +} + +extension LayoutRequirementSyntax { + enum LayoutConstraintOptions: TokenSpecSet { + case _Trivial + case _TrivialAtMost + case _UnknownLayout + case _RefCountedObject + case _NativeRefCountedObject + case _Class + case _NativeClass + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(._Trivial): + self = ._Trivial + case TokenSpec(._TrivialAtMost): + self = ._TrivialAtMost + case TokenSpec(._UnknownLayout): + self = ._UnknownLayout + case TokenSpec(._RefCountedObject): + self = ._RefCountedObject + case TokenSpec(._NativeRefCountedObject): + self = ._NativeRefCountedObject + case TokenSpec(._Class): + self = ._Class + case TokenSpec(._NativeClass): + self = ._NativeClass + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case ._Trivial: + return .keyword(._Trivial) + case ._TrivialAtMost: + return .keyword(._TrivialAtMost) + case ._UnknownLayout: + return .keyword(._UnknownLayout) + case ._RefCountedObject: + return .keyword(._RefCountedObject) + case ._NativeRefCountedObject: + return .keyword(._NativeRefCountedObject) + case ._Class: + return .keyword(._Class) + case ._NativeClass: + return .keyword(._NativeClass) + } + } + } +} + +extension MemberTypeIdentifierSyntax { + enum NameOptions: TokenSpecSet { + case identifier + case `self` + case `Self` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`Self`): + self = .`Self` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .`self`: + return .keyword(.`self`) + case .`Self`: + return .keyword(.`Self`) + } + } + } +} + +extension MetatypeTypeSyntax { + enum TypeOrProtocolOptions: TokenSpecSet { + case `Type` + case `Protocol` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`Type`): + self = .`Type` + case TokenSpec(.`Protocol`): + self = .`Protocol` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`Type`: + return .keyword(.`Type`) + case .`Protocol`: + return .keyword(.`Protocol`) + } + } + } +} + +extension MoveExprSyntax { + enum MoveKeywordOptions: TokenSpecSet { + case _move + case consume + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(._move): + self = ._move + case TokenSpec(.consume): + self = .consume + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case ._move: + return .keyword(._move) + case .consume: + return .keyword(.consume) + } + } + } +} + +extension MultipleTrailingClosureElementSyntax { + enum LabelOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension OperatorDeclSyntax { + enum FixityOptions: TokenSpecSet { + case prefix + case postfix + case infix + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.prefix): + self = .prefix + case TokenSpec(.postfix): + self = .postfix + case TokenSpec(.infix): + self = .infix + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .prefix: + return .keyword(.prefix) + case .postfix: + return .keyword(.postfix) + case .infix: + return .keyword(.infix) + } + } + } +} + +extension OperatorDeclSyntax { + enum IdentifierOptions: TokenSpecSet { + case binaryOperator + case prefixOperator + case postfixOperator + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.binaryOperator): + self = .binaryOperator + case TokenSpec(.prefixOperator): + self = .prefixOperator + case TokenSpec(.postfixOperator): + self = .postfixOperator + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .binaryOperator: + return .binaryOperator + case .prefixOperator: + return .prefixOperator + case .postfixOperator: + return .postfixOperator + } + } + } +} + +extension OptionalBindingConditionSyntax { + enum BindingKeywordOptions: TokenSpecSet { + case `let` + case `var` + case `inout` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`let`): + self = .`let` + case TokenSpec(.`var`): + self = .`var` + case TokenSpec(.`inout`): + self = .`inout` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`let`: + return .keyword(.`let`) + case .`var`: + return .keyword(.`var`) + case .`inout`: + return .keyword(.`inout`) + } + } + } +} + +extension PrecedenceGroupAssignmentSyntax { + enum FlagOptions: TokenSpecSet { + case `true` + case `false` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`true`): + self = .`true` + case TokenSpec(.`false`): + self = .`false` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`true`: + return .keyword(.`true`) + case .`false`: + return .keyword(.`false`) + } + } + } +} + +extension PrecedenceGroupAssociativitySyntax { + enum ValueOptions: TokenSpecSet { + case left + case right + case none + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.left): + self = .left + case TokenSpec(.right): + self = .right + case TokenSpec(.none): + self = .none + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .left: + return .keyword(.left) + case .right: + return .keyword(.right) + case .none: + return .keyword(.none) + } + } + } +} + +extension PrecedenceGroupRelationSyntax { + enum HigherThanOrLowerThanKeywordOptions: TokenSpecSet { + case higherThan + case lowerThan + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.higherThan): + self = .higherThan + case TokenSpec(.lowerThan): + self = .lowerThan + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .higherThan: + return .keyword(.higherThan) + case .lowerThan: + return .keyword(.lowerThan) + } + } + } +} + +extension QualifiedDeclNameSyntax { + enum NameOptions: TokenSpecSet { + case identifier + case `self` + case `Self` + case `init` + case binaryOperator + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`Self`): + self = .`Self` + case TokenSpec(.`init`): + self = .`init` + case TokenSpec(.binaryOperator): + self = .binaryOperator + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .`self`: + return .keyword(.`self`) + case .`Self`: + return .keyword(.`Self`) + case .`init`: + return .keyword(.`init`) + case .binaryOperator: + return .binaryOperator + } + } + } +} + +extension SameTypeRequirementSyntax { + enum EqualityTokenOptions: TokenSpecSet { + case binaryOperator + case prefixOperator + case postfixOperator + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.binaryOperator): + self = .binaryOperator + case TokenSpec(.prefixOperator): + self = .prefixOperator + case TokenSpec(.postfixOperator): + self = .postfixOperator + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .binaryOperator: + return .binaryOperator + case .prefixOperator: + return .prefixOperator + case .postfixOperator: + return .postfixOperator + } + } + } +} + +extension SimpleTypeIdentifierSyntax { + enum NameOptions: TokenSpecSet { + case identifier + case `self` + case `Self` + case `Any` + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.`self`): + self = .`self` + case TokenSpec(.`Self`): + self = .`Self` + case TokenSpec(.`Any`): + self = .`Any` + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .`self`: + return .keyword(.`self`) + case .`Self`: + return .keyword(.`Self`) + case .`Any`: + return .keyword(.`Any`) + case .wildcard: + return .wildcard + } + } + } +} + +extension StringLiteralExprSyntax { + enum OpenQuoteOptions: TokenSpecSet { + case stringQuote + case multilineStringQuote + case singleQuote + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.stringQuote): + self = .stringQuote + case TokenSpec(.multilineStringQuote): + self = .multilineStringQuote + case TokenSpec(.singleQuote): + self = .singleQuote + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .stringQuote: + return .stringQuote + case .multilineStringQuote: + return .multilineStringQuote + case .singleQuote: + return .singleQuote + } + } + } +} + +extension StringLiteralExprSyntax { + enum CloseQuoteOptions: TokenSpecSet { + case stringQuote + case multilineStringQuote + case singleQuote + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.stringQuote): + self = .stringQuote + case TokenSpec(.multilineStringQuote): + self = .multilineStringQuote + case TokenSpec(.singleQuote): + self = .singleQuote + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .stringQuote: + return .stringQuote + case .multilineStringQuote: + return .multilineStringQuote + case .singleQuote: + return .singleQuote + } + } + } +} + +extension TryExprSyntax { + enum QuestionOrExclamationMarkOptions: TokenSpecSet { + case postfixQuestionMark + case exclamationMark + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.postfixQuestionMark): + self = .postfixQuestionMark + case TokenSpec(.exclamationMark): + self = .exclamationMark + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .postfixQuestionMark: + return .postfixQuestionMark + case .exclamationMark: + return .exclamationMark + } + } + } +} + +extension TupleExprElementSyntax { + enum LabelOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension TupleTypeElementSyntax { + enum NameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension TupleTypeElementSyntax { + enum SecondNameOptions: TokenSpecSet { + case identifier + case wildcard + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.identifier): + self = .identifier + case TokenSpec(.wildcard): + self = .wildcard + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .identifier: + return .identifier + case .wildcard: + return .wildcard + } + } + } +} + +extension UnresolvedAsExprSyntax { + enum QuestionOrExclamationMarkOptions: TokenSpecSet { + case postfixQuestionMark + case exclamationMark + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.postfixQuestionMark): + self = .postfixQuestionMark + case TokenSpec(.exclamationMark): + self = .exclamationMark + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .postfixQuestionMark: + return .postfixQuestionMark + case .exclamationMark: + return .exclamationMark + } + } + } +} + +extension ValueBindingPatternSyntax { + enum BindingKeywordOptions: TokenSpecSet { + case `let` + case `var` + case `inout` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`let`): + self = .`let` + case TokenSpec(.`var`): + self = .`var` + case TokenSpec(.`inout`): + self = .`inout` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`let`: + return .keyword(.`let`) + case .`var`: + return .keyword(.`var`) + case .`inout`: + return .keyword(.`inout`) + } + } + } +} + +extension VariableDeclSyntax { + enum BindingKeywordOptions: TokenSpecSet { + case `let` + case `var` + case `inout` + + init?(lexeme: Lexer.Lexeme) { + switch PrepareForKeywordMatch(lexeme) { + case TokenSpec(.`let`): + self = .`let` + case TokenSpec(.`var`): + self = .`var` + case TokenSpec(.`inout`): + self = .`inout` + default: + return nil + } + } + + var spec: TokenSpec { + switch self { + case .`let`: + return .keyword(.`let`) + case .`var`: + return .keyword(.`var`) + case .`inout`: + return .keyword(.`inout`) + } + } + } +} diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 86c59babd58..6658304b40d 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -856,7 +856,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { .keyword("public"), .keyword("reasync"), .keyword("required"), - .keyword("setter_access"), .keyword("static"), .keyword("unowned"), .keyword("weak")