Skip to content

Commit abbb7dc

Browse files
ahoppenahoppen
committed
Migrate a few more uses of RawTokenKind to TokenSpec 
1 parent fa6d909 commit abbb7dc

File tree

15 files changed

+115
-97
lines changed

15 files changed

+115
-97
lines changed

‎CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/TokenSpecStaticMembersFile.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,6 @@ let tokenSpecStaticMembersFile = SourceFileSyntax(
2727
DeclSyntax("static var \(raw: token.swiftKind): TokenSpec { return TokenSpec(.\(raw: token.swiftKind)) }")
2828
}
2929

30-
DeclSyntax("static func keyword(_ keyword: Keyword) -> TokenSpec { return TokenSpec(.keyword(keyword)) }")
30+
DeclSyntax("static func keyword(_ keyword: Keyword) -> TokenSpec { return TokenSpec(keyword) }")
3131
}
3232
}

‎Sources/SwiftParser/Attributes.swift

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -315,7 +315,7 @@ extension Parser {
315315
}
316316
case .rethrows:
317317
let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
318-
let (unexpectedBeforeAttributeName, attributeName) = self.expect(TokenSpec(.keyword(.rethrows), remapping: .identifier))
318+
let (unexpectedBeforeAttributeName, attributeName) = self.expect(TokenSpec(.rethrows, remapping: .identifier))
319319
return .attribute(
320320
RawAttributeSyntax(
321321
unexpectedBeforeAtSign,
@@ -1158,15 +1158,15 @@ extension Parser.Lookahead {
11581158
// Alternatively, we might have a token that illustrates we're not going to
11591159
// get anything following the attribute, which means the parentheses describe
11601160
// what follows the attribute.
1161-
switch lookahead.currentToken.rawTokenKind {
1162-
case .arrow,
1163-
.keyword(.throw),
1164-
.keyword(.throws),
1165-
.keyword(.rethrows),
1166-
.rightParen,
1167-
.rightBrace,
1168-
.rightSquareBracket,
1169-
.rightAngle:
1161+
switch lookahead.currentToken {
1162+
case TokenSpec(.arrow),
1163+
TokenSpec(.throw),
1164+
TokenSpec(.throws),
1165+
TokenSpec(.rethrows),
1166+
TokenSpec(.rightParen),
1167+
TokenSpec(.rightBrace),
1168+
TokenSpec(.rightSquareBracket),
1169+
TokenSpec(.rightAngle):
11701170
return false
11711171
case _ where lookahead.at(.keyword(.async)):
11721172
return false

‎Sources/SwiftParser/Declarations.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1477,7 +1477,7 @@ extension Parser {
14771477
inMemberDeclList: Bool = false
14781478
) -> RawVariableDeclSyntax {
14791479
let (unexpectedBeforeIntroducer, introducer) = self.eat(handle)
1480-
let hasTryBeforeIntroducer = unexpectedBeforeIntroducer?.containsToken(where: { $0.tokenKind == .keyword(.try) }) ?? false
1480+
let hasTryBeforeIntroducer = unexpectedBeforeIntroducer?.containsToken(where: { TokenSpec(.try) ~= $0 }) ?? false
14811481

14821482
var elements = [RawPatternBindingSyntax]()
14831483
do {

‎Sources/SwiftParser/Expressions.swift

Lines changed: 23 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -356,7 +356,7 @@ extension Parser {
356356
return parseUnresolvedAsExpr(handle: handle)
357357

358358
case (.async, _)?:
359-
if self.peek().rawTokenKind == .arrow || self.peek().rawTokenKind == .keyword(.throws) {
359+
if self.peek().rawTokenKind == .arrow || TokenSpec(.throws) ~= self.peek() {
360360
fallthrough
361361
} else {
362362
return nil
@@ -494,20 +494,20 @@ extension Parser {
494494
// First check to see if we have the start of a regex literal `/.../`.
495495
// tryLexRegexLiteral(/*forUnappliedOperator*/ false)
496496

497-
switch self.currentToken.rawTokenKind {
498-
case .keyword(.repeat):
497+
switch self.currentToken {
498+
case TokenSpec(.repeat):
499499
// 'repeat' is the start of a pack expansion expression.
500500
return RawExprSyntax(parsePackExpansionExpr(flavor, pattern: pattern))
501501

502502
// Try parse an 'if' or 'switch' as an expression. Note we do this here in
503503
// parseUnaryExpression as we don't allow postfix syntax to hang off such
504504
// expressions to avoid ambiguities such as postfix '.member', which can
505505
// currently be parsed as a static dot member for a result builder.
506-
case .keyword(.switch):
506+
case TokenSpec(.switch):
507507
return RawExprSyntax(
508508
parseSwitchExpression(switchHandle: .constant(.keyword(.switch)))
509509
)
510-
case .keyword(.if):
510+
case TokenSpec(.if):
511511
return RawExprSyntax(
512512
parseIfExpression(ifHandle: .constant(.keyword(.if)))
513513
)
@@ -2063,7 +2063,7 @@ extension Parser.Lookahead {
20632063
}
20642064

20652065
// If this is the start of a switch body, this isn't a trailing closure.
2066-
if self.peek().rawTokenKind == .keyword(.case) {
2066+
if TokenSpec(.case) ~= self.peek() {
20672067
return false
20682068
}
20692069

@@ -2104,23 +2104,23 @@ extension Parser.Lookahead {
21042104
return false
21052105
}
21062106

2107-
switch backtrack.currentToken.rawTokenKind {
2108-
case .leftBrace,
2109-
.keyword(.where),
2110-
.comma:
2107+
switch backtrack.currentToken {
2108+
case TokenSpec(.leftBrace),
2109+
TokenSpec(.where),
2110+
TokenSpec(.comma):
21112111
return true
2112-
case .leftSquareBracket,
2113-
.leftParen,
2114-
.period,
2115-
.keyword(.is),
2116-
.keyword(.as),
2117-
.postfixQuestionMark,
2118-
.infixQuestionMark,
2119-
.exclamationMark,
2120-
.colon,
2121-
.equal,
2122-
.postfixOperator,
2123-
.binaryOperator:
2112+
case TokenSpec(.leftSquareBracket),
2113+
TokenSpec(.leftParen),
2114+
TokenSpec(.period),
2115+
TokenSpec(.is),
2116+
TokenSpec(.as),
2117+
TokenSpec(.postfixQuestionMark),
2118+
TokenSpec(.infixQuestionMark),
2119+
TokenSpec(.exclamationMark),
2120+
TokenSpec(.colon),
2121+
TokenSpec(.equal),
2122+
TokenSpec(.postfixOperator),
2123+
TokenSpec(.binaryOperator):
21242124
return !backtrack.currentToken.isAtStartOfLine
21252125
default:
21262126
return false
@@ -2559,14 +2559,7 @@ extension Parser.Lookahead {
25592559
return true
25602560
}
25612561

2562-
if self.peek().rawTokenKind != .identifier,
2563-
self.peek().rawTokenKind != .keyword(.Self),
2564-
self.peek().rawTokenKind != .keyword(.self),
2565-
!self.peek().isLexerClassifiedKeyword
2566-
{
2567-
return false
2568-
}
2569-
return true
2562+
return self.peek().isLexerClassifiedKeyword || TokenSpec(.identifier) ~= self.peek()
25702563
}
25712564

25722565
fileprivate func isNextTokenCallPattern() -> Bool {

‎Sources/SwiftParser/Lookahead.swift

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -254,7 +254,7 @@ extension Parser.Lookahead {
254254
// If we have a 'didSet' or a 'willSet' label, disambiguate immediately as
255255
// an accessor block.
256256
let nextToken = self.peek()
257-
if TokenSpec(.keyword(.didSet)) ~= nextToken || TokenSpec(.keyword(.willSet)) ~= nextToken {
257+
if TokenSpec(.didSet) ~= nextToken || TokenSpec(.willSet) ~= nextToken {
258258
return true
259259
}
260260

@@ -286,7 +286,7 @@ extension Parser.Lookahead {
286286
// MARK: Skipping Tokens
287287

288288
extension Parser.Lookahead {
289-
mutating func skipUntil(_ t1: RawTokenKind, _ t2: RawTokenKind) {
289+
mutating func skipUntil(_ t1: TokenSpec, _ t2: TokenSpec) {
290290
return skip(initialState: .skipUntil(t1, t2))
291291
}
292292

@@ -346,7 +346,7 @@ extension Parser.Lookahead {
346346
/// Execute code after skipping bracketed tokens detected from `skipSingle`.
347347
case skipSinglePost(start: BracketedTokens)
348348
/// Skip until either `t1` or `t2`.
349-
case skipUntil(_ t1: RawTokenKind, _ t2: RawTokenKind)
349+
case skipUntil(_ t1: TokenSpec, _ t2: TokenSpec)
350350
}
351351

352352
/// A non-recursie function to skip tokens.

‎Sources/SwiftParser/Modifiers.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ extension Parser {
196196

197197
let unexpectedBeforeDetail: RawUnexpectedNodesSyntax?
198198
let detail: RawTokenSyntax
199-
if let setHandle = canRecoverTo(TokenSpec(.keyword(.set), recoveryPrecedence: .weakBracketClose)) {
199+
if let setHandle = canRecoverTo(TokenSpec(.set, recoveryPrecedence: .weakBracketClose)) {
200200
(unexpectedBeforeDetail, detail) = eat(setHandle)
201201
} else {
202202
unexpectedBeforeDetail = nil

‎Sources/SwiftParser/Patterns.swift

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -55,13 +55,13 @@ extension Parser {
5555
case varKeyword
5656

5757
init?(lexeme: Lexer.Lexeme) {
58-
switch lexeme.rawTokenKind {
59-
case .leftParen: self = .leftParen
60-
case .wildcard: self = .wildcard
61-
case .identifier: self = .identifier
62-
case .dollarIdentifier: self = .dollarIdentifier
63-
case .keyword(.let): self = .letKeyword
64-
case .keyword(.var): self = .varKeyword
58+
switch lexeme {
59+
case TokenSpec(.leftParen): self = .leftParen
60+
case TokenSpec(.wildcard): self = .wildcard
61+
case TokenSpec(.identifier): self = .identifier
62+
case TokenSpec(.dollarIdentifier): self = .dollarIdentifier
63+
case TokenSpec(.let): self = .letKeyword
64+
case TokenSpec(.var): self = .varKeyword
6565
default: return nil
6666
}
6767
}
@@ -296,12 +296,12 @@ extension Parser.Lookahead {
296296
case leftParen
297297

298298
init?(lexeme: Lexer.Lexeme) {
299-
switch lexeme.rawTokenKind {
300-
case .identifier: self = .identifier
301-
case .wildcard: self = .wildcard
302-
case .keyword(.let): self = .letKeyword
303-
case .keyword(.var): self = .varKeyword
304-
case .leftParen: self = .leftParen
299+
switch lexeme {
300+
case TokenSpec(.identifier): self = .identifier
301+
case TokenSpec(.wildcard): self = .wildcard
302+
case TokenSpec(.let): self = .letKeyword
303+
case TokenSpec(.var): self = .varKeyword
304+
case TokenSpec(.leftParen): self = .leftParen
305305
default: return nil
306306
}
307307
}

‎Sources/SwiftParser/Specifiers.swift

Lines changed: 22 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -331,6 +331,18 @@ extension RawTypeEffectSpecifiersSyntax: RawEffectSpecifiersTrait {
331331
}
332332
}
333333

334+
extension TokenConsumer {
335+
mutating func at<SpecSet1: TokenSpecSet, SpecSet2: TokenSpecSet>(anyIn specSet1: SpecSet1.Type, or specSet2: SpecSet2.Type) -> (TokenSpec, TokenConsumptionHandle)? {
336+
if let (spec, handle) = self.at(anyIn: specSet1) {
337+
return (spec.spec, handle)
338+
} else if let (spec, handle) = self.at(anyIn: specSet2) {
339+
return (spec.spec, handle)
340+
} else {
341+
return nil
342+
}
343+
}
344+
}
345+
334346
// MARK: - Parsing effect specifiers
335347

336348
extension Parser {
@@ -378,13 +390,15 @@ extension Parser {
378390

379391
var unexpectedAfterThrowsLoopProgress = LoopProgressCondition()
380392
while unexpectedAfterThrowsLoopProgress.evaluate(self.currentToken) {
381-
if let misspelledAsync = self.consume(ifAnyIn: S.MisspelledAsyncSpecifiers.self) ?? self.consume(ifAnyIn: S.CorrectAsyncTokenKinds.self) {
393+
if let (_, handle) = self.at(anyIn: S.MisspelledAsyncSpecifiers.self, or: S.CorrectAsyncTokenKinds.self) {
394+
let misspelledAsync = self.eat(handle)
382395
unexpectedAfterThrows.append(RawSyntax(misspelledAsync))
383396
if asyncKeyword == nil {
384397
// Handle `async` after `throws`
385398
asyncKeyword = missingToken(.keyword(.async))
386399
}
387-
} else if let misspelledThrows = self.consume(ifAnyIn: S.MisspelledThrowsTokenKinds.self) ?? self.consume(ifAnyIn: S.CorrectThrowsTokenKinds.self) {
400+
} else if let (_, handle) = self.at(anyIn: S.MisspelledThrowsTokenKinds.self, or: S.CorrectThrowsTokenKinds.self) {
401+
let misspelledThrows = self.eat(handle)
388402
unexpectedAfterThrows.append(RawSyntax(misspelledThrows))
389403
} else {
390404
break
@@ -423,15 +437,17 @@ extension Parser {
423437
var unexpected: [RawTokenSyntax] = []
424438
var loopProgress = LoopProgressCondition()
425439
while loopProgress.evaluate(self.currentToken) {
426-
if let misspelledAsync = self.consume(ifAnyIn: S.MisspelledAsyncSpecifiers.self) ?? self.consume(ifAnyIn: S.CorrectAsyncTokenKinds.self) {
440+
if let (spec, handle) = self.at(anyIn: S.MisspelledAsyncSpecifiers.self, or: S.CorrectAsyncTokenKinds.self) {
441+
let misspelledAsync = self.eat(handle)
427442
unexpected.append(misspelledAsync)
428443
if effectSpecifiers?.asyncSpecifier == nil {
429-
synthesizedAsync = missingToken(misspelledAsync.tokenKind)
444+
synthesizedAsync = missingToken(spec)
430445
}
431-
} else if let misspelledThrows = self.consume(ifAnyIn: S.MisspelledThrowsTokenKinds.self) ?? self.consume(ifAnyIn: S.CorrectThrowsTokenKinds.self) {
446+
} else if let (spec, handle) = self.at(anyIn: S.MisspelledThrowsTokenKinds.self, or: S.CorrectThrowsTokenKinds.self) {
447+
let misspelledThrows = self.eat(handle)
432448
unexpected.append(misspelledThrows)
433449
if effectSpecifiers?.throwsSpecifier == nil {
434-
synthesizedThrows = missingToken(misspelledThrows.tokenKind)
450+
synthesizedThrows = missingToken(spec)
435451
}
436452
} else {
437453
break

‎Sources/SwiftParser/Statements.swift

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -353,7 +353,7 @@ extension Parser {
353353
@_spi(RawSyntax)
354354
public mutating func parseThrowStatement(throwHandle: RecoveryConsumptionHandle) -> RawThrowStmtSyntax {
355355
let (unexpectedBeforeThrowKeyword, throwKeyword) = self.eat(throwHandle)
356-
let hasMisplacedTry = unexpectedBeforeThrowKeyword?.containsToken(where: { $0.tokenKind == .keyword(.try) }) ?? false
356+
let hasMisplacedTry = unexpectedBeforeThrowKeyword?.containsToken(where: { TokenSpec(.try) ~= $0 }) ?? false
357357
var expr = self.parseExpression()
358358
if hasMisplacedTry && !expr.is(RawTryExprSyntax.self) {
359359
expr = RawExprSyntax(
@@ -692,7 +692,7 @@ extension Parser {
692692
@_spi(RawSyntax)
693693
public mutating func parseReturnStatement(returnHandle: RecoveryConsumptionHandle) -> RawReturnStmtSyntax {
694694
let (unexpectedBeforeRet, ret) = self.eat(returnHandle)
695-
let hasMisplacedTry = unexpectedBeforeRet?.containsToken(where: { $0.tokenKind == .keyword(.try) }) ?? false
695+
let hasMisplacedTry = unexpectedBeforeRet?.containsToken(where: { TokenSpec(.try) ~= $0 }) ?? false
696696

697697
// Handle the ambiguity between consuming the expression and allowing the
698698
// enclosing stmt-brace to get it by eagerly eating it unless the return is

‎Sources/SwiftParser/StringLiterals.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -487,7 +487,7 @@ extension Parser {
487487
// This allows us to skip over extraneous identifiers etc. in an unterminated string interpolation.
488488
var unexpectedBeforeRightParen: [RawTokenSyntax] = []
489489
var unexpectedProgress = LoopProgressCondition()
490-
while !self.at(.rightParen, .stringSegment, .backslash) && !self.at(openQuoteKind, .eof) && unexpectedProgress.evaluate(self.currentToken) {
490+
while !self.at(.rightParen, .stringSegment, .backslash) && !self.at(TokenSpec(openQuoteKind), .eof) && unexpectedProgress.evaluate(self.currentToken) {
491491
unexpectedBeforeRightParen.append(self.consumeAnyToken())
492492
}
493493
let rightParen = self.expectWithoutRecovery(.rightParen)

‎Sources/SwiftParser/TokenConsumer.swift

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -57,27 +57,27 @@ extension TokenConsumer {
5757
/// Returns whether the the current token matches one of the two specs.
5858
@inline(__always)
5959
mutating func at(
60-
_ spec1: RawTokenKind,
61-
_ spec2: RawTokenKind
60+
_ spec1: TokenSpec,
61+
_ spec2: TokenSpec
6262
) -> Bool {
6363
switch self.currentToken {
64-
case TokenSpec(spec1): return true
65-
case TokenSpec(spec2): return true
64+
case spec1: return true
65+
case spec2: return true
6666
default: return false
6767
}
6868
}
6969

7070
/// Returns whether the the current token matches one of the three specs.
7171
@inline(__always)
7272
mutating func at(
73-
_ spec1: RawTokenKind,
74-
_ spec2: RawTokenKind,
75-
_ spec3: RawTokenKind
73+
_ spec1: TokenSpec,
74+
_ spec2: TokenSpec,
75+
_ spec3: TokenSpec
7676
) -> Bool {
7777
switch self.currentToken {
78-
case TokenSpec(spec1): return true
79-
case TokenSpec(spec2): return true
80-
case TokenSpec(spec3): return true
78+
case spec1: return true
79+
case spec2: return true
80+
case spec3: return true
8181
default: return false
8282
}
8383
}

‎Sources/SwiftParser/TokenSpec.swift

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,15 @@ struct TokenSpec {
9999
atStartOfLine: token.leadingTrivia.contains(where: { $0.isNewline })
100100
)
101101
}
102+
103+
@inline(__always)
104+
static func ~= (kind: TokenSpec, token: RawTokenSyntax) -> Bool {
105+
return kind.matches(
106+
rawTokenKind: token.tokenKind,
107+
text: token.tokenView.rawText,
108+
atStartOfLine: token.leadingTriviaPieces.contains(where: \.isNewline)
109+
)
110+
}
102111
}
103112

104113
extension TokenConsumer {

‎Sources/SwiftParser/TokenSpecSet.swift

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -269,9 +269,9 @@ enum DeclarationStart: TokenSpecSet {
269269

270270
var spec: TokenSpec {
271271
switch self {
272-
case .actorKeyword: return TokenSpec(.keyword(.actor), recoveryPrecedence: .declKeyword)
272+
case .actorKeyword: return TokenSpec(.actor, recoveryPrecedence: .declKeyword)
273273
case .associatedtypeKeyword: return .keyword(.associatedtype)
274-
case .caseKeyword: return TokenSpec(.keyword(.case), recoveryPrecedence: .declKeyword)
274+
case .caseKeyword: return TokenSpec(.case, recoveryPrecedence: .declKeyword)
275275
case .classKeyword: return .keyword(.class)
276276
case .deinitKeyword: return .keyword(.deinit)
277277
case .enumKeyword: return .keyword(.enum)
@@ -280,7 +280,7 @@ enum DeclarationStart: TokenSpecSet {
280280
case .importKeyword: return .keyword(.import)
281281
case .initKeyword: return .keyword(.`init`)
282282
case .letKeyword: return .keyword(.let)
283-
case .macroKeyword: return TokenSpec(.keyword(.macro), recoveryPrecedence: .declKeyword)
283+
case .macroKeyword: return TokenSpec(.macro, recoveryPrecedence: .declKeyword)
284284
case .operatorKeyword: return .keyword(.operator)
285285
case .precedencegroupKeyword: return .keyword(.precedencegroup)
286286
case .protocolKeyword: return .keyword(.protocol)
@@ -345,7 +345,7 @@ enum IdentifierOrRethrowsTokens: TokenSpecSet {
345345
case .capitalSelfKeyword: return .keyword(.Self)
346346
case .identifier: return .identifier
347347
case .selfKeyword: return .keyword(.self)
348-
case .rethrowsKeyword: return TokenSpec(.keyword(.rethrows), remapping: .identifier)
348+
case .rethrowsKeyword: return TokenSpec(.rethrows, remapping: .identifier)
349349
}
350350
}
351351
}

0 commit comments

Comments
 (0)