Skip to content

Commit 30eade9

Browse files
kimdvkimdv
committed
Use new generated spec set
1 parent 13c611d commit 30eade9

File tree

5 files changed

+32
-275
lines changed

5 files changed

+32
-275
lines changed

‎Sources/SwiftParser/Attributes.swift

Lines changed: 3 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -363,33 +363,10 @@ extension Parser {
363363
)
364364
}
365365

366-
enum DifferentiabilityKind: TokenSpecSet {
367-
case reverse
368-
case _linear
369-
case _forward
370-
371-
init?(lexeme: Lexer.Lexeme) {
372-
switch PrepareForKeywordMatch(lexeme) {
373-
case TokenSpec(.reverse): self = .reverse
374-
case TokenSpec(._linear): self = ._linear
375-
case TokenSpec(._forward): self = ._forward
376-
default: return nil
377-
}
378-
}
379-
380-
var spec: TokenSpec {
381-
switch self {
382-
case .reverse: return .keyword(.reverse)
383-
case ._linear: return .keyword(._linear)
384-
case ._forward: return .keyword(._forward)
385-
}
386-
}
387-
}
388-
389366
mutating func parseDifferentiableAttributeArguments() -> RawDifferentiableAttributeArgumentsSyntax {
390367
let diffKind: RawTokenSyntax?
391368
let diffKindComma: RawTokenSyntax?
392-
if let (_, handle) = self.at(anyIn: DifferentiabilityKind.self) {
369+
if let (_, handle) = self.at(anyIn: DifferentiableAttributeArgumentsSyntax.DiffKindOptions.self) {
393370
diffKind = self.eat(handle)
394371
diffKindComma = self.consume(if: .comma)
395372
} else {
@@ -474,30 +451,7 @@ extension Parser {
474451
}
475452

476453
mutating func parseDifferentiabilityParameter() -> RawDifferentiabilityParamSyntax? {
477-
enum ExpectedTokenKind: TokenSpecSet {
478-
case identifier
479-
case integerLiteral
480-
case `self`
481-
482-
init?(lexeme: Lexer.Lexeme) {
483-
switch PrepareForKeywordMatch(lexeme) {
484-
case TokenSpec(.identifier): self = .identifier
485-
case TokenSpec(.integerLiteral): self = .integerLiteral
486-
case TokenSpec(.self): self = .self
487-
default: return nil
488-
}
489-
}
490-
491-
var spec: TokenSpec {
492-
switch self {
493-
case .identifier: return .identifier
494-
case .integerLiteral: return .integerLiteral
495-
case .self: return .keyword(.self)
496-
}
497-
}
498-
}
499-
500-
switch self.at(anyIn: ExpectedTokenKind.self) {
454+
switch self.at(anyIn: DifferentiabilityParamSyntax.ParameterOptions.self) {
501455
case (.identifier, let handle)?:
502456
let token = self.eat(handle)
503457
let comma = self.consume(if: .comma)
@@ -656,46 +610,12 @@ extension Parser {
656610
}
657611

658612
extension Parser {
659-
enum SpecializeParameter: TokenSpecSet {
660-
case target
661-
case availability
662-
case exported
663-
case kind
664-
case spi
665-
case spiModule
666-
case available
667-
668-
init?(lexeme: Lexer.Lexeme) {
669-
switch PrepareForKeywordMatch(lexeme) {
670-
case TokenSpec(.target): self = .target
671-
case TokenSpec(.availability): self = .availability
672-
case TokenSpec(.exported): self = .exported
673-
case TokenSpec(.kind): self = .kind
674-
case TokenSpec(.spi): self = .spi
675-
case TokenSpec(.spiModule): self = .spiModule
676-
case TokenSpec(.available): self = .available
677-
default: return nil
678-
}
679-
}
680-
681-
var spec: TokenSpec {
682-
switch self {
683-
case .target: return .keyword(.target)
684-
case .availability: return .keyword(.availability)
685-
case .exported: return .keyword(.exported)
686-
case .kind: return .keyword(.kind)
687-
case .spi: return .keyword(.spi)
688-
case .spiModule: return .keyword(.spiModule)
689-
case .available: return .keyword(.available)
690-
}
691-
}
692-
}
693613
mutating func parseSpecializeAttributeSpecList() -> RawSpecializeAttributeSpecListSyntax {
694614
var elements = [RawSpecializeAttributeSpecListSyntax.Element]()
695615
// Parse optional "exported" and "kind" labeled parameters.
696616
var loopProgress = LoopProgressCondition()
697617
while !self.at(.eof, .rightParen, .keyword(.where)) && loopProgress.evaluate(currentToken) {
698-
switch self.at(anyIn: SpecializeParameter.self) {
618+
switch self.at(anyIn: LabeledSpecializeEntrySyntax.LabelOptions.self) {
699619
case (.target, let handle)?:
700620
let ident = self.eat(handle)
701621
let (unexpectedBeforeColon, colon) = self.expect(.colon)

‎Sources/SwiftParser/Declarations.swift

Lines changed: 27 additions & 102 deletions
Original file line numberDiff line numberDiff line change
@@ -339,48 +339,7 @@ extension Parser {
339339
}
340340

341341
mutating func parseImportKind() -> RawTokenSyntax? {
342-
enum ImportKind: TokenSpecSet {
343-
case `typealias`
344-
case `struct`
345-
case `class`
346-
case `enum`
347-
case `protocol`
348-
case `var`
349-
case `let`
350-
case `func`
351-
case `inout`
352-
353-
var spec: TokenSpec {
354-
switch self {
355-
case .typealias: return .keyword(.typealias)
356-
case .struct: return .keyword(.struct)
357-
case .class: return .keyword(.class)
358-
case .enum: return .keyword(.enum)
359-
case .protocol: return .keyword(.protocol)
360-
case .var: return .keyword(.var)
361-
case .let: return .keyword(.let)
362-
case .func: return .keyword(.func)
363-
case .inout: return .keyword(.inout)
364-
}
365-
}
366-
367-
init?(lexeme: Lexer.Lexeme) {
368-
switch PrepareForKeywordMatch(lexeme) {
369-
case TokenSpec(.typealias): self = .typealias
370-
case TokenSpec(.struct): self = .struct
371-
case TokenSpec(.class): self = .class
372-
case TokenSpec(.enum): self = .enum
373-
case TokenSpec(.protocol): self = .protocol
374-
case TokenSpec(.var): self = .var
375-
case TokenSpec(.let): self = .let
376-
case TokenSpec(.func): self = .func
377-
case TokenSpec(.inout): self = .inout
378-
default: return nil
379-
}
380-
}
381-
}
382-
383-
return self.consume(ifAnyIn: ImportKind.self)
342+
return self.consume(ifAnyIn: ImportDeclSyntax.ImportKindOptions.self)
384343
}
385344

386345
mutating func parseImportPath() -> RawImportPathSyntax {
@@ -581,56 +540,6 @@ extension Parser {
581540
)
582541
}
583542

584-
enum LayoutConstraint: TokenSpecSet {
585-
case _Trivial
586-
case _TrivialAtMost
587-
case _UnknownLayout
588-
case _RefCountedObjectLayout
589-
case _NativeRefCountedObjectLayout
590-
case _Class
591-
case _NativeClass
592-
593-
init?(lexeme: Lexer.Lexeme) {
594-
switch PrepareForKeywordMatch(lexeme) {
595-
case TokenSpec(._Trivial): self = ._Trivial
596-
case TokenSpec(._TrivialAtMost): self = ._TrivialAtMost
597-
case TokenSpec(._UnknownLayout): self = ._UnknownLayout
598-
case TokenSpec(._RefCountedObject): self = ._RefCountedObjectLayout
599-
case TokenSpec(._NativeRefCountedObject): self = ._NativeRefCountedObjectLayout
600-
case TokenSpec(._Class): self = ._Class
601-
case TokenSpec(._NativeClass): self = ._NativeClass
602-
default: return nil
603-
}
604-
}
605-
606-
var spec: TokenSpec {
607-
switch self {
608-
case ._Trivial: return .keyword(._Trivial)
609-
case ._TrivialAtMost: return .keyword(._TrivialAtMost)
610-
case ._UnknownLayout: return .keyword(._UnknownLayout)
611-
case ._RefCountedObjectLayout: return .keyword(._RefCountedObject)
612-
case ._NativeRefCountedObjectLayout: return .keyword(._NativeRefCountedObject)
613-
case ._Class: return .keyword(._Class)
614-
case ._NativeClass: return .keyword(._NativeClass)
615-
}
616-
}
617-
618-
var hasArguments: Bool {
619-
switch self {
620-
case ._Trivial,
621-
._TrivialAtMost:
622-
return true
623-
624-
case ._UnknownLayout,
625-
._RefCountedObjectLayout,
626-
._NativeRefCountedObjectLayout,
627-
._Class,
628-
._NativeClass:
629-
return false
630-
}
631-
}
632-
}
633-
634543
mutating func parseGenericWhereClause() -> RawGenericWhereClauseSyntax {
635544
let (unexpectedBeforeWhereKeyword, whereKeyword) = self.expect(.keyword(.where))
636545

@@ -690,7 +599,7 @@ extension Parser {
690599
case (.colon, let handle)?:
691600
let colon = self.eat(handle)
692601
// A conformance-requirement.
693-
if let (layoutConstraint, handle) = self.at(anyIn: LayoutConstraint.self) {
602+
if let (layoutConstraint, handle) = self.at(anyIn: LayoutRequirementSyntax.LayoutConstraintOptions.self) {
694603
// Parse a layout constraint.
695604
let constraint = self.eat(handle)
696605

@@ -701,9 +610,25 @@ extension Parser {
701610
let alignment: RawTokenSyntax?
702611
let unexpectedBeforeRightParen: RawUnexpectedNodesSyntax?
703612
let rightParen: RawTokenSyntax?
613+
614+
var hasArguments: Bool {
615+
switch layoutConstraint {
616+
case ._Trivial,
617+
._TrivialAtMost:
618+
return true
619+
620+
case ._UnknownLayout,
621+
._RefCountedObject,
622+
._NativeRefCountedObject,
623+
._Class,
624+
._NativeClass:
625+
return false
626+
}
627+
}
628+
704629
// Unlike the other layout constraints, _Trivial's argument list
705630
// is optional.
706-
if layoutConstraint.hasArguments && (layoutConstraint != ._Trivial || self.at(.leftParen)) {
631+
if hasArguments && (layoutConstraint != ._Trivial || self.at(.leftParen)) {
707632
(unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
708633
size = self.expectWithoutRecovery(.integerLiteral)
709634
comma = self.consume(if: .comma)
@@ -1296,7 +1221,7 @@ extension Parser {
12961221

12971222
// Parse getter and setter.
12981223
let accessor: RawSubscriptDeclSyntax.Accessor?
1299-
if self.at(.leftBrace) || self.at(anyIn: AccessorKind.self) != nil {
1224+
if self.at(.leftBrace) || self.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) != nil {
13001225
accessor = self.parseGetSet()
13011226
} else {
13021227
accessor = nil
@@ -1418,7 +1343,7 @@ extension Parser {
14181343
}
14191344

14201345
let accessor: RawPatternBindingSyntax.Accessor?
1421-
if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorKind.self) != nil && !self.at(.keyword(.`init`))) {
1346+
if self.at(.leftBrace) || (inMemberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) != nil && !self.at(.keyword(.`init`))) {
14221347
switch self.parseGetSet() {
14231348
case .accessors(let accessors):
14241349
accessor = .accessors(accessors)
@@ -1456,19 +1381,19 @@ extension Parser {
14561381
struct AccessorIntroducer {
14571382
var attributes: RawAttributeListSyntax?
14581383
var modifier: RawDeclModifierSyntax?
1459-
var kind: AccessorKind
1384+
var kind: AccessorDeclSyntax.AccessorKindOptions
14601385
var unexpectedBeforeToken: RawUnexpectedNodesSyntax?
14611386
var token: RawTokenSyntax
14621387
}
14631388

14641389
mutating func parseAccessorIntroducer(
1465-
forcedKind: (AccessorKind, TokenConsumptionHandle)? = nil
1390+
forcedKind: (AccessorDeclSyntax.AccessorKindOptions, TokenConsumptionHandle)? = nil
14661391
) -> AccessorIntroducer? {
14671392
// Check there is an identifier before consuming
14681393
var look = self.lookahead()
14691394
let _ = look.consumeAttributeList()
14701395
let hasModifier = look.consume(if: .keyword(.mutating), .keyword(.nonmutating), .keyword(.__consuming)) != nil
1471-
guard let (kind, _) = look.at(anyIn: AccessorKind.self) ?? forcedKind else {
1396+
guard let (kind, _) = look.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) ?? forcedKind else {
14721397
return nil
14731398
}
14741399

@@ -1530,7 +1455,7 @@ extension Parser {
15301455
//
15311456
// set-name ::= '(' identifier ')'
15321457
let parameter: RawAccessorParameterSyntax?
1533-
if [AccessorKind.set, .willSet, .didSet, .`init`].contains(introducer.kind), let lparen = self.consume(if: .leftParen) {
1458+
if [AccessorDeclSyntax.AccessorKindOptions.set, .willSet, .didSet, .`init`].contains(introducer.kind), let lparen = self.consume(if: .leftParen) {
15341459
let (unexpectedBeforeName, name) = self.expectIdentifier()
15351460
let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen)
15361461
parameter = RawAccessorParameterSyntax(
@@ -1575,7 +1500,7 @@ extension Parser {
15751500
// Parse getter and setter.
15761501
let unexpectedBeforeLBrace: RawUnexpectedNodesSyntax?
15771502
let lbrace: RawTokenSyntax
1578-
if self.at(anyIn: AccessorKind.self) != nil {
1503+
if self.at(anyIn: AccessorDeclSyntax.AccessorKindOptions.self) != nil {
15791504
unexpectedBeforeLBrace = nil
15801505
lbrace = missingToken(.leftBrace)
15811506
} else {
@@ -1976,7 +1901,7 @@ extension Parser {
19761901
case (.assignment, let handle)?:
19771902
let assignmentKeyword = self.eat(handle)
19781903
let (unexpectedBeforeColon, colon) = self.expect(.colon)
1979-
let (unexpectedBeforeFlag, flag) = self.expect(.keyword(.true), .keyword(.false), default: .keyword(.true))
1904+
let (unexpectedBeforeFlag, flag) = self.expect(anyIn: PrecedenceGroupAssignmentSyntax.FlagOptions.self, default: .true)
19801905
let unexpectedAfterFlag: RawUnexpectedNodesSyntax?
19811906
if flag.isMissing, let unexpectedIdentifier = self.consume(if: TokenSpec(.identifier, allowAtStartOfLine: false)) {
19821907
unexpectedAfterFlag = RawUnexpectedNodesSyntax([unexpectedIdentifier], arena: self.arena)

‎Sources/SwiftParser/Expressions.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2620,7 +2620,7 @@ extension Parser {
26202620
var versionInfo: RawCanImportVersionInfoSyntax?
26212621

26222622
if let comma = self.consume(if: .comma) {
2623-
let (unexpectedBeforeLabel, label) = self.expect(.keyword(._version), .keyword(._underlyingVersion), default: .keyword(._version))
2623+
let (unexpectedBeforeLabel, label) = self.expect(anyIn: CanImportVersionInfoSyntax.LabelOptions.self, default: ._version)
26242624
let (unexpectedBeforeColon, colon) = self.expect(.colon)
26252625

26262626
let version = self.parseVersionTuple(maxComponentCount: 4)

‎Sources/SwiftParser/TokenSpecSet.swift

Lines changed: 0 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -23,59 +23,6 @@ protocol TokenSpecSet: CaseIterable {
2323

2424
// MARK: - Subsets
2525

26-
enum AccessorKind: TokenSpecSet {
27-
case `get`
28-
case `set`
29-
case `didSet`
30-
case `willSet`
31-
case `init`
32-
case unsafeAddress
33-
case addressWithOwner
34-
case addressWithNativeOwner
35-
case unsafeMutableAddress
36-
case mutableAddressWithOwner
37-
case mutableAddressWithNativeOwner
38-
case _read
39-
case _modify
40-
41-
init?(lexeme: Lexer.Lexeme) {
42-
switch PrepareForKeywordMatch(lexeme) {
43-
case TokenSpec(.get): self = .get
44-
case TokenSpec(.set): self = .set
45-
case TokenSpec(.didSet): self = .didSet
46-
case TokenSpec(.willSet): self = .willSet
47-
case TokenSpec(.`init`): self = .`init`
48-
case TokenSpec(.unsafeAddress): self = .unsafeAddress
49-
case TokenSpec(.addressWithOwner): self = .addressWithOwner
50-
case TokenSpec(.addressWithNativeOwner): self = .addressWithNativeOwner
51-
case TokenSpec(.unsafeMutableAddress): self = .unsafeMutableAddress
52-
case TokenSpec(.mutableAddressWithOwner): self = .mutableAddressWithOwner
53-
case TokenSpec(.mutableAddressWithNativeOwner): self = .mutableAddressWithNativeOwner
54-
case TokenSpec(._read): self = ._read
55-
case TokenSpec(._modify): self = ._modify
56-
default: return nil
57-
}
58-
}
59-
60-
var spec: TokenSpec {
61-
switch self {
62-
case .get: return .keyword(.get)
63-
case .set: return .keyword(.set)
64-
case .didSet: return .keyword(.didSet)
65-
case .willSet: return .keyword(.willSet)
66-
case .`init`: return .keyword(.`init`)
67-
case .unsafeAddress: return .keyword(.unsafeAddress)
68-
case .addressWithOwner: return .keyword(.addressWithOwner)
69-
case .addressWithNativeOwner: return .keyword(.addressWithNativeOwner)
70-
case .unsafeMutableAddress: return .keyword(.unsafeMutableAddress)
71-
case .mutableAddressWithOwner: return .keyword(.mutableAddressWithOwner)
72-
case .mutableAddressWithNativeOwner: return .keyword(.mutableAddressWithNativeOwner)
73-
case ._read: return .keyword(._read)
74-
case ._modify: return .keyword(._modify)
75-
}
76-
}
77-
}
78-
7926
enum CanBeStatementStart: TokenSpecSet {
8027
case _forget // NOTE: support for deprecated _forget
8128
case `break`

0 commit comments

Comments
 (0)