From b4155dbb55e678741ae51f5af1b2b4141d6c52e0 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 11:14:08 -0800 Subject: [PATCH 01/12] Replace throwsSpecifier/thrownTypeClause with a unified throwsClause This better matches the proposal grammar better and keeps the `throws` (or `rethrows`) alongside the thrown error type. --- .../Sources/SyntaxSupport/CommonNodes.swift | 65 ++++++++----------- .../SyntaxSupport/SyntaxNodeKind.swift | 2 +- .../Sources/SyntaxSupport/Traits.swift | 14 +--- .../ValidateSyntaxNodes.swift | 10 --- 4 files changed, 30 insertions(+), 61 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index b6109579836..ea233325fb6 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -81,29 +81,36 @@ public let COMMON_NODES: [Node] = [ ), Node( - kind: .thrownTypeClause, + kind: .throwsClause, base: .syntax, - nameForDiagnostics: "thrown type clause", - documentation: "The specific error type that a function can throw.", - traits: [ - "Parenthesized" - ], + nameForDiagnostics: "throws clause", children: [ + Child( + name: "throwsSpecifier", + kind: .token(choices: [.keyword(.throws), .keyword(.rethrows)]), + documentation: "The `throws` keyword." + ), Child( name: "leftParen", kind: .token(choices: [.token(.leftParen)]), - documentation: "The '(' to open the thrown type clause." + experimentalFeature: .typedThrows, + documentation: "The '(' to open the thrown error type specification.", + isOptional: true ), Child( name: "type", kind: .node(kind: .type), + experimentalFeature: .typedThrows, nameForDiagnostics: "thrown type", - documentation: "The thrown error type." + documentation: "The thrown error type.", + isOptional: true ), Child( name: "rightParen", kind: .token(choices: [.token(.rightParen)]), - documentation: "The ')' to closure the thrown type clause." + experimentalFeature: .typedThrows, + documentation: "The ')' to close the thrown error type specification.", + isOptional: true ), ] ), @@ -123,16 +130,9 @@ public let COMMON_NODES: [Node] = [ isOptional: true ), Child( - name: "throwsSpecifier", - kind: .token(choices: [.keyword(.throws)]), - documentation: "The `throws` keyword.", - isOptional: true - ), - Child( - name: "thrownError", - kind: .node(kind: .thrownTypeClause), - experimentalFeature: .typedThrows, - documentation: "The specific error type thrown by this accessor.", + name: "throwsClause", + kind: .node(kind: .throwsClause), + documentation: "The clause specifying thrown errors", isOptional: true ), ] @@ -153,16 +153,9 @@ public let COMMON_NODES: [Node] = [ isOptional: true ), Child( - name: "throwsSpecifier", - kind: .token(choices: [.keyword(.throws), .keyword(.rethrows)]), - documentation: "The `throws` or `rethrows` keyword.", - isOptional: true - ), - Child( - name: "thrownError", - kind: .node(kind: .thrownTypeClause), - experimentalFeature: .typedThrows, - documentation: "The specific error type thrown by this function.", + name: "throwsClause", + kind: .node(kind: .throwsClause), + documentation: "The clause specifying thrown errors", isOptional: true ), ] @@ -179,7 +172,7 @@ public let COMMON_NODES: [Node] = [ kind: .token(choices: [.keyword(.async)]), documentation: "The `async` keyword.", isOptional: true - ) + ), ] ), @@ -363,15 +356,9 @@ public let COMMON_NODES: [Node] = [ isOptional: true ), Child( - name: "throwsSpecifier", - kind: .token(choices: [.keyword(.throws)]), - isOptional: true - ), - Child( - name: "thrownError", - kind: .node(kind: .thrownTypeClause), - experimentalFeature: .typedThrows, - documentation: "The specific error type thrown by this function type.", + name: "throwsClause", + kind: .node(kind: .throwsClause), + documentation: "The clause specifying thrown errors", isOptional: true ), ] diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index 6b36c0b76cf..3db67234b1e 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -269,7 +269,7 @@ public enum SyntaxNodeKind: String, CaseIterable { case switchExpr case ternaryExpr case thenStmt - case thrownTypeClause + case throwsClause case throwStmt case tryExpr case tupleExpr diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index d8adc8cdb8c..be4d4224c84 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -62,17 +62,9 @@ public let TRAITS: [Trait] = [ children: [ Child(name: "unexpectedBeforeAsyncSpecifier", kind: .node(kind: .unexpectedNodes), isOptional: true), Child(name: "asyncSpecifier", kind: .token(choices: [.keyword(.async), .keyword(.reasync)]), isOptional: true), - Child(name: "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier", kind: .node(kind: .unexpectedNodes), isOptional: true), - Child(name: "throwsSpecifier", kind: .token(choices: [.keyword(.throws), .keyword(.rethrows)]), isOptional: true), - Child(name: "unexpectedBetweenThrowsSpecifierAndThrownError", kind: .node(kind: .unexpectedNodes), isOptional: true), - Child( - name: "thrownError", - kind: .node(kind: .thrownTypeClause), - experimentalFeature: .typedThrows, - documentation: "The specific thrown error type.", - isOptional: true - ), - Child(name: "unexpectedAfterThrownError", kind: .node(kind: .unexpectedNodes), isOptional: true), + Child(name: "unexpectedBetweenAsyncSpecifierAndThrowsClause", kind: .node(kind: .unexpectedNodes), isOptional: true), + Child(name: "throwsClause", kind: .node(kind: .throwsClause), isOptional: true), + Child(name: "unexpectedAfterThrowsClause", kind: .node(kind: .unexpectedNodes), isOptional: true), ] ), Trait( diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift index 179c4a30e77..7bd727a9bff 100644 --- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift +++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift @@ -225,11 +225,6 @@ class ValidateSyntaxNodes: XCTestCase { message: "child 'asyncSpecifier' has a single keyword as its only token choice and should thus be named 'asyncKeyword'" // To be consistent with AsyncSpecifier properties that can be both 'async' and 'reasync' ), - ValidationFailure( - node: .accessorEffectSpecifiers, - message: "child 'throwsSpecifier' has a single keyword as its only token choice and should thus be named 'throwsKeyword'" - // To be consistent with AsyncSpecifier properties that can be both 'async' and 'reasync' - ), ValidationFailure( node: .deinitializerEffectSpecifiers, message: "child 'asyncSpecifier' has a single keyword as its only token choice and should thus be named 'asyncKeyword'" @@ -240,11 +235,6 @@ class ValidateSyntaxNodes: XCTestCase { message: "child 'asyncSpecifier' has a single keyword as its only token choice and should thus be named 'asyncKeyword'" // To be consistent with AsyncSpecifier properties that can be both 'async' and 'reasync' ), - ValidationFailure( - node: .typeEffectSpecifiers, - message: "child 'throwsSpecifier' has a single keyword as its only token choice and should thus be named 'throwsKeyword'" - // To be consistent with AsyncSpecifier properties that can be both 'async' and 'reasync' - ), // MARK: Two tokens with same kind in a node // If there are two tokens of the same kind in a node, we can't follow the naming rule without conflict From d4134ac1d949ac224d2cbe3636989bd6660a6fb5 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 11:42:12 -0800 Subject: [PATCH 02/12] Regenerate with the new ThrowsClauseSyntax --- .../generated/Parser+TokenSpecSet.swift | 82 ++++---- .../generated/ChildNameForDiagnostics.swift | 2 +- .../SyntaxKindNameForDiagnostics.swift | 4 +- .../generated/SwiftSyntax.md | 2 +- .../generated/ChildNameForKeyPath.swift | 68 +++---- .../generated/SyntaxAnyVisitor.swift | 4 +- .../generated/SyntaxBaseNodes.swift | 2 +- .../SwiftSyntax/generated/SyntaxEnum.swift | 6 +- .../SwiftSyntax/generated/SyntaxKind.swift | 6 +- .../generated/SyntaxRewriter.swift | 12 +- .../SwiftSyntax/generated/SyntaxTraits.swift | 25 +-- .../SwiftSyntax/generated/SyntaxVisitor.swift | 16 +- .../generated/raw/RawSyntaxNodesAB.swift | 34 +--- .../generated/raw/RawSyntaxNodesEF.swift | 34 +--- .../generated/raw/RawSyntaxNodesTUVWXYZ.swift | 92 ++++----- .../generated/raw/RawSyntaxValidation.swift | 30 ++- .../generated/syntaxNodes/SyntaxNodesAB.swift | 72 ++----- .../generated/syntaxNodes/SyntaxNodesEF.swift | 74 ++----- .../syntaxNodes/SyntaxNodesTUVWXYZ.swift | 191 +++++++++--------- 19 files changed, 318 insertions(+), 438 deletions(-) diff --git a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift index 6e17ced402c..ad50c94d08e 100644 --- a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift +++ b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift @@ -1392,47 +1392,6 @@ extension FunctionEffectSpecifiersSyntax { } } -extension FunctionEffectSpecifiersSyntax { - @_spi(Diagnostics) - public enum ThrowsSpecifierOptions: TokenSpecSet { - case `throws` - case `rethrows` - - init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) { - 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) - } - } - - /// Returns a token that satisfies the `TokenSpec` of this case. - /// - /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text. - @_spi(Diagnostics) - public var tokenSyntax: TokenSyntax { - switch self { - case .throws: - return .keyword(.throws) - case .rethrows: - return .keyword(.rethrows) - } - } - } -} - extension FunctionParameterSyntax { @_spi(Diagnostics) public enum FirstNameOptions: TokenSpecSet { @@ -2774,6 +2733,47 @@ extension StringLiteralExprSyntax { } } +extension ThrowsClauseSyntax { + @_spi(Diagnostics) + public enum ThrowsSpecifierOptions: TokenSpecSet { + case `throws` + case `rethrows` + + init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) { + 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) + } + } + + /// Returns a token that satisfies the `TokenSpec` of this case. + /// + /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text. + @_spi(Diagnostics) + public var tokenSyntax: TokenSyntax { + switch self { + case .throws: + return .keyword(.throws) + case .rethrows: + return .keyword(.rethrows) + } + } + } +} + extension TryExprSyntax { @_spi(Diagnostics) public enum QuestionOrExclamationMarkOptions: TokenSpecSet { diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index d0545bdd0d8..887bd24fb40 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -334,7 +334,7 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "first choice" case \TernaryExprSyntax.elseExpression: return "second choice" - case \ThrownTypeClauseSyntax.type: + case \ThrowsClauseSyntax.type: return "thrown type" case \TuplePatternElementSyntax.label: return "label" diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index 93aa8b3955a..02aa8637e61 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -363,8 +363,8 @@ extension SyntaxKind { return "'then' statement" case .throwStmt: return "'throw' statement" - case .thrownTypeClause: - return "thrown type clause" + case .throwsClause: + return "throws clause" case .tryExpr: return "'try' expression" case .tupleExpr: diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md index a850a994cc3..17ef8a8a6d2 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -380,7 +380,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax - - - -- +- - - - diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index e87cebaf991..baf3d208f38 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -61,16 +61,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBeforeAsyncSpecifier" case \AccessorEffectSpecifiersSyntax.asyncSpecifier: return "asyncSpecifier" - case \AccessorEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: - return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" - case \AccessorEffectSpecifiersSyntax.throwsSpecifier: - return "throwsSpecifier" - case \AccessorEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownError: - return "unexpectedBetweenThrowsSpecifierAndThrownError" - case \AccessorEffectSpecifiersSyntax.thrownError: - return "thrownError" - case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrownError: - return "unexpectedAfterThrownError" + case \AccessorEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsClause: + return "unexpectedBetweenAsyncSpecifierAndThrowsClause" + case \AccessorEffectSpecifiersSyntax.throwsClause: + return "throwsClause" + case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrowsClause: + return "unexpectedAfterThrowsClause" case \AccessorParametersSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \AccessorParametersSyntax.leftParen: @@ -1415,16 +1411,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBeforeAsyncSpecifier" case \FunctionEffectSpecifiersSyntax.asyncSpecifier: return "asyncSpecifier" - case \FunctionEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: - return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" - case \FunctionEffectSpecifiersSyntax.throwsSpecifier: - return "throwsSpecifier" - case \FunctionEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownError: - return "unexpectedBetweenThrowsSpecifierAndThrownError" - case \FunctionEffectSpecifiersSyntax.thrownError: - return "thrownError" - case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrownError: - return "unexpectedAfterThrownError" + case \FunctionEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsClause: + return "unexpectedBetweenAsyncSpecifierAndThrowsClause" + case \FunctionEffectSpecifiersSyntax.throwsClause: + return "throwsClause" + case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrowsClause: + return "unexpectedAfterThrowsClause" case \FunctionParameterClauseSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \FunctionParameterClauseSyntax.leftParen: @@ -3105,19 +3097,23 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "expression" case \ThrowStmtSyntax.unexpectedAfterExpression: return "unexpectedAfterExpression" - case \ThrownTypeClauseSyntax.unexpectedBeforeLeftParen: - return "unexpectedBeforeLeftParen" - case \ThrownTypeClauseSyntax.leftParen: + case \ThrowsClauseSyntax.unexpectedBeforeThrowsSpecifier: + return "unexpectedBeforeThrowsSpecifier" + case \ThrowsClauseSyntax.throwsSpecifier: + return "throwsSpecifier" + case \ThrowsClauseSyntax.unexpectedBetweenThrowsSpecifierAndLeftParen: + return "unexpectedBetweenThrowsSpecifierAndLeftParen" + case \ThrowsClauseSyntax.leftParen: return "leftParen" - case \ThrownTypeClauseSyntax.unexpectedBetweenLeftParenAndType: + case \ThrowsClauseSyntax.unexpectedBetweenLeftParenAndType: return "unexpectedBetweenLeftParenAndType" - case \ThrownTypeClauseSyntax.type: + case \ThrowsClauseSyntax.type: return "type" - case \ThrownTypeClauseSyntax.unexpectedBetweenTypeAndRightParen: + case \ThrowsClauseSyntax.unexpectedBetweenTypeAndRightParen: return "unexpectedBetweenTypeAndRightParen" - case \ThrownTypeClauseSyntax.rightParen: + case \ThrowsClauseSyntax.rightParen: return "rightParen" - case \ThrownTypeClauseSyntax.unexpectedAfterRightParen: + case \ThrowsClauseSyntax.unexpectedAfterRightParen: return "unexpectedAfterRightParen" case \TryExprSyntax.unexpectedBeforeTryKeyword: return "unexpectedBeforeTryKeyword" @@ -3267,16 +3263,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBeforeAsyncSpecifier" case \TypeEffectSpecifiersSyntax.asyncSpecifier: return "asyncSpecifier" - case \TypeEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: - return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" - case \TypeEffectSpecifiersSyntax.throwsSpecifier: - return "throwsSpecifier" - case \TypeEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownError: - return "unexpectedBetweenThrowsSpecifierAndThrownError" - case \TypeEffectSpecifiersSyntax.thrownError: - return "thrownError" - case \TypeEffectSpecifiersSyntax.unexpectedAfterThrownError: - return "unexpectedAfterThrownError" + case \TypeEffectSpecifiersSyntax.unexpectedBetweenAsyncSpecifierAndThrowsClause: + return "unexpectedBetweenAsyncSpecifierAndThrowsClause" + case \TypeEffectSpecifiersSyntax.throwsClause: + return "throwsClause" + case \TypeEffectSpecifiersSyntax.unexpectedAfterThrowsClause: + return "unexpectedAfterThrowsClause" case \TypeExprSyntax.unexpectedBeforeType: return "unexpectedBeforeType" case \TypeExprSyntax.type: diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index 7734160b505..7aa92b754b0 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -2036,11 +2036,11 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: ThrownTypeClauseSyntax) -> SyntaxVisitorContinueKind { + override open func visit(_ node: ThrowsClauseSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } - override open func visitPost(_ node: ThrownTypeClauseSyntax) { + override open func visitPost(_ node: ThrowsClauseSyntax) { visitAnyPost(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index d46e0a2ba60..b4084ddc80b 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -1765,7 +1765,7 @@ extension Syntax { .node(TernaryExprSyntax.self), .node(ThenStmtSyntax.self), .node(ThrowStmtSyntax.self), - .node(ThrownTypeClauseSyntax.self), + .node(ThrowsClauseSyntax.self), .node(TryExprSyntax.self), .node(TupleExprSyntax.self), .node(TuplePatternElementListSyntax.self), diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift index e371669cf4f..e8b8993a98f 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -267,7 +267,7 @@ public enum SyntaxEnum { #endif case thenStmt(ThenStmtSyntax) case throwStmt(ThrowStmtSyntax) - case thrownTypeClause(ThrownTypeClauseSyntax) + case throwsClause(ThrowsClauseSyntax) case tryExpr(TryExprSyntax) case tupleExpr(TupleExprSyntax) case tuplePatternElementList(TuplePatternElementListSyntax) @@ -799,8 +799,8 @@ public extension Syntax { return .thenStmt(ThenStmtSyntax(self)!) case .throwStmt: return .throwStmt(ThrowStmtSyntax(self)!) - case .thrownTypeClause: - return .thrownTypeClause(ThrownTypeClauseSyntax(self)!) + case .throwsClause: + return .throwsClause(ThrowsClauseSyntax(self)!) case .tryExpr: return .tryExpr(TryExprSyntax(self)!) case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 92931b634f0..9910c763f45 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -267,7 +267,7 @@ public enum SyntaxKind { #endif case thenStmt case throwStmt - case thrownTypeClause + case throwsClause case tryExpr case tupleExpr case tuplePatternElementList @@ -920,8 +920,8 @@ public enum SyntaxKind { return ThenStmtSyntax.self case .throwStmt: return ThrowStmtSyntax.self - case .thrownTypeClause: - return ThrownTypeClauseSyntax.self + case .throwsClause: + return ThrowsClauseSyntax.self case .tryExpr: return TryExprSyntax.self case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index 929a7b0fa54..1c4438990b6 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1808,10 +1808,10 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } - /// Visit a ``ThrownTypeClauseSyntax``. + /// Visit a ``ThrowsClauseSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node - open func visit(_ node: ThrownTypeClauseSyntax) -> ThrownTypeClauseSyntax { + open func visit(_ node: ThrowsClauseSyntax) -> ThrowsClauseSyntax { return visitChildren(node) } @@ -3100,9 +3100,9 @@ open class SyntaxRewriter { return { self.visitImpl($0, ThrowStmtSyntax.self, self.visit) } - case .thrownTypeClause: + case .throwsClause: return { - self.visitImpl($0, ThrownTypeClauseSyntax.self, self.visit) + self.visitImpl($0, ThrowsClauseSyntax.self, self.visit) } case .tryExpr: return { @@ -3730,8 +3730,8 @@ open class SyntaxRewriter { return visitImpl(node, ThenStmtSyntax.self, visit) case .throwStmt: return visitImpl(node, ThrowStmtSyntax.self, visit) - case .thrownTypeClause: - return visitImpl(node, ThrownTypeClauseSyntax.self, visit) + case .throwsClause: + return visitImpl(node, ThrowsClauseSyntax.self, visit) case .tryExpr: return visitImpl(node, TryExprSyntax.self, visit) case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index be59cfabdb5..7026ee859d1 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -137,34 +137,17 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { + var unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? { get set } - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: - /// - `throws` - /// - `rethrows` - var throwsSpecifier: TokenSyntax? { - get - set - } - - var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { - get - set - } - - /// The specific thrown error type. - @_spi(ExperimentalLanguageFeatures) - var thrownError: ThrownTypeClauseSyntax? { + var throwsClause: ThrowsClauseSyntax? { get set } - var unexpectedAfterThrownError: UnexpectedNodesSyntax? { + var unexpectedAfterThrowsClause: UnexpectedNodesSyntax? { get set } @@ -842,8 +825,6 @@ extension SwitchCaseSyntax: WithStatementsSyntax {} extension SwitchExprSyntax: BracedSyntax {} -extension ThrownTypeClauseSyntax: ParenthesizedSyntax {} - extension TupleExprSyntax: ParenthesizedSyntax {} extension TuplePatternElementSyntax: WithTrailingCommaSyntax {} diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index b7505bdf2c9..995dd8881d7 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -2998,16 +2998,16 @@ open class SyntaxVisitor { open func visitPost(_ node: ThrowStmtSyntax) { } - /// Visiting ``ThrownTypeClauseSyntax`` specifically. + /// Visiting ``ThrowsClauseSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. - open func visit(_ node: ThrownTypeClauseSyntax) -> SyntaxVisitorContinueKind { + open func visit(_ node: ThrowsClauseSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } - /// The function called after visiting ``ThrownTypeClauseSyntax`` and its descendants. + /// The function called after visiting ``ThrowsClauseSyntax`` and its descendants. /// - node: the node we just finished visiting. - open func visitPost(_ node: ThrownTypeClauseSyntax) { + open func visitPost(_ node: ThrowsClauseSyntax) { } /// Visiting ``TryExprSyntax`` specifically. @@ -4428,9 +4428,9 @@ open class SyntaxVisitor { return { self.visitImpl($0, ThrowStmtSyntax.self, self.visit, self.visitPost) } - case .thrownTypeClause: + case .throwsClause: return { - self.visitImpl($0, ThrownTypeClauseSyntax.self, self.visit, self.visitPost) + self.visitImpl($0, ThrowsClauseSyntax.self, self.visit, self.visitPost) } case .tryExpr: return { @@ -5061,8 +5061,8 @@ open class SyntaxVisitor { visitImpl(node, ThenStmtSyntax.self, visit, visitPost) case .throwStmt: visitImpl(node, ThrowStmtSyntax.self, visit, visitPost) - case .thrownTypeClause: - visitImpl(node, ThrownTypeClauseSyntax.self, visit, visitPost) + case .throwsClause: + visitImpl(node, ThrowsClauseSyntax.self, visit, visitPost) case .tryExpr: visitImpl(node, TryExprSyntax.self, visit, visitPost) case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift index 3ccb2034184..cd241cdd08c 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift @@ -310,23 +310,19 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { public init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil, asyncSpecifier: RawTokenSyntax?, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, - throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? = nil, - thrownError: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? = nil, + throwsClause: RawThrowsClauseSyntax?, + _ unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorEffectSpecifiers, uninitializedCount: 7, arena: arena) { layout in + kind: .accessorEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsyncSpecifier?.raw layout[1] = asyncSpecifier?.raw - layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw - layout[3] = throwsSpecifier?.raw - layout[4] = unexpectedBetweenThrowsSpecifierAndThrownError?.raw - layout[5] = thrownError?.raw - layout[6] = unexpectedAfterThrownError?.raw + layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw + layout[3] = throwsClause?.raw + layout[4] = unexpectedAfterThrowsClause?.raw } self.init(unchecked: raw) } @@ -339,25 +335,17 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwsSpecifier: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var throwsClause: RawThrowsClauseSyntax? { + layoutView.children[3].map(RawThrowsClauseSyntax.init(raw:)) } - public var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { + public var unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - - public var thrownError: RawThrownTypeClauseSyntax? { - layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) - } - - public var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift index bfca770259b..ac9d0aaf04a 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift @@ -2000,23 +2000,19 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { public init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil, asyncSpecifier: RawTokenSyntax?, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, - throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? = nil, - thrownError: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? = nil, + throwsClause: RawThrowsClauseSyntax?, + _ unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionEffectSpecifiers, uninitializedCount: 7, arena: arena) { layout in + kind: .functionEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsyncSpecifier?.raw layout[1] = asyncSpecifier?.raw - layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw - layout[3] = throwsSpecifier?.raw - layout[4] = unexpectedBetweenThrowsSpecifierAndThrownError?.raw - layout[5] = thrownError?.raw - layout[6] = unexpectedAfterThrownError?.raw + layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw + layout[3] = throwsClause?.raw + layout[4] = unexpectedAfterThrowsClause?.raw } self.init(unchecked: raw) } @@ -2029,25 +2025,17 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwsSpecifier: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var throwsClause: RawThrowsClauseSyntax? { + layoutView.children[3].map(RawThrowsClauseSyntax.init(raw:)) } - public var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { + public var unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - - public var thrownError: RawThrownTypeClauseSyntax? { - layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) - } - - public var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift index a7317d6c413..f1bea4c0867 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift @@ -251,14 +251,14 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } @_spi(RawSyntax) -public struct RawThrownTypeClauseSyntax: RawSyntaxNodeProtocol { +public struct RawThrowsClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .thrownTypeClause + return raw.kind == .throwsClause } public var raw: RawSyntax @@ -280,56 +280,68 @@ public struct RawThrownTypeClauseSyntax: RawSyntaxNodeProtocol { } public init( - _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, - leftParen: RawTokenSyntax, + _ unexpectedBeforeThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, + throwsSpecifier: RawTokenSyntax, + _ unexpectedBetweenThrowsSpecifierAndLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax?, _ unexpectedBetweenLeftParenAndType: RawUnexpectedNodesSyntax? = nil, - type: RawTypeSyntax, + type: RawTypeSyntax?, _ unexpectedBetweenTypeAndRightParen: RawUnexpectedNodesSyntax? = nil, - rightParen: RawTokenSyntax, + rightParen: RawTokenSyntax?, _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .thrownTypeClause, uninitializedCount: 7, arena: arena) { layout in + kind: .throwsClause, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpectedBeforeLeftParen?.raw - layout[1] = leftParen.raw - layout[2] = unexpectedBetweenLeftParenAndType?.raw - layout[3] = type.raw - layout[4] = unexpectedBetweenTypeAndRightParen?.raw - layout[5] = rightParen.raw - layout[6] = unexpectedAfterRightParen?.raw + layout[0] = unexpectedBeforeThrowsSpecifier?.raw + layout[1] = throwsSpecifier.raw + layout[2] = unexpectedBetweenThrowsSpecifierAndLeftParen?.raw + layout[3] = leftParen?.raw + layout[4] = unexpectedBetweenLeftParenAndType?.raw + layout[5] = type?.raw + layout[6] = unexpectedBetweenTypeAndRightParen?.raw + layout[7] = rightParen?.raw + layout[8] = unexpectedAfterRightParen?.raw } self.init(unchecked: raw) } - public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + public var unexpectedBeforeThrowsSpecifier: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var leftParen: RawTokenSyntax { + public var throwsSpecifier: RawTokenSyntax { layoutView.children[1].map(RawTokenSyntax.init(raw:))! } - public var unexpectedBetweenLeftParenAndType: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndLeftParen: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var type: RawTypeSyntax { - layoutView.children[3].map(RawTypeSyntax.init(raw:))! + public var leftParen: RawTokenSyntax? { + layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenTypeAndRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenLeftParenAndType: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var rightParen: RawTokenSyntax { - layoutView.children[5].map(RawTokenSyntax.init(raw:))! + public var type: RawTypeSyntax? { + layoutView.children[5].map(RawTypeSyntax.init(raw:)) } - public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenTypeAndRightParen: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var rightParen: RawTokenSyntax? { + layoutView.children[7].map(RawTokenSyntax.init(raw:)) + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -1216,23 +1228,19 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { public init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil, asyncSpecifier: RawTokenSyntax?, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, - throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? = nil, - thrownError: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? = nil, + throwsClause: RawThrowsClauseSyntax?, + _ unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeEffectSpecifiers, uninitializedCount: 7, arena: arena) { layout in + kind: .typeEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsyncSpecifier?.raw layout[1] = asyncSpecifier?.raw - layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw - layout[3] = throwsSpecifier?.raw - layout[4] = unexpectedBetweenThrowsSpecifierAndThrownError?.raw - layout[5] = thrownError?.raw - layout[6] = unexpectedAfterThrownError?.raw + layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw + layout[3] = throwsClause?.raw + layout[4] = unexpectedAfterThrowsClause?.raw } self.init(unchecked: raw) } @@ -1245,25 +1253,17 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[1].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? { layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var throwsSpecifier: RawTokenSyntax? { - layoutView.children[3].map(RawTokenSyntax.init(raw:)) + public var throwsClause: RawThrowsClauseSyntax? { + layoutView.children[3].map(RawThrowsClauseSyntax.init(raw:)) } - public var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { + public var unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - - public var thrownError: RawThrownTypeClauseSyntax? { - layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) - } - - public var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { - layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) - } } @_spi(RawSyntax) diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index c06fe43a8fa..95269b722d4 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -253,14 +253,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 11, verify(layout[11], as: RawCodeBlockSyntax?.self)) assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self)) case .accessorEffectSpecifiers: - assert(layout.count == 7) + assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax?.self, tokenChoices: [.keyword("async")])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("throws")])) + assertNoError(kind, 3, verify(layout[3], as: RawThrowsClauseSyntax?.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeClauseSyntax?.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .accessorParameters: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -1263,14 +1261,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 15, verify(layout[15], as: RawCodeBlockSyntax?.self)) assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self)) case .functionEffectSpecifiers: - assert(layout.count == 7) + assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax?.self, tokenChoices: [.keyword("async"), .keyword("reasync")])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("throws"), .keyword("rethrows")])) + assertNoError(kind, 3, verify(layout[3], as: RawThrowsClauseSyntax?.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeClauseSyntax?.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .functionParameterClause: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -2483,15 +2479,17 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - case .thrownTypeClause: - assert(layout.count == 7) + case .throwsClause: + assert(layout.count == 9) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("throws"), .keyword("rethrows")])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawTypeSyntax.self)) + assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.leftParen)])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) + assertNoError(kind, 5, verify(layout[5], as: RawTypeSyntax?.self)) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.rightParen)])) + assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self)) case .tryExpr: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -2589,14 +2587,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 3, verify(layout[3], as: RawTypeSyntax.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) case .typeEffectSpecifiers: - assert(layout.count == 7) + assert(layout.count == 5) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax?.self, tokenChoices: [.keyword("async")])) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("throws")])) + assertNoError(kind, 3, verify(layout[3], as: RawThrowsClauseSyntax?.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeClauseSyntax?.self)) - assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .typeExpr: assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index cdcc5a8960f..d80a95acd8a 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -524,8 +524,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Children /// /// - `asyncSpecifier`: `async`? -/// - `throwsSpecifier`: `throws`? -/// - `thrownError`: ``ThrownTypeClauseSyntax``? +/// - `throwsClause`: ``ThrowsClauseSyntax``? /// /// ### Contained in /// @@ -543,18 +542,15 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// - Parameters: /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. /// - asyncSpecifier: The `async` keyword. - /// - throwsSpecifier: The `throws` keyword. - /// - thrownError: The specific error type thrown by this accessor. + /// - throwsClause: The clause specifying thrown errors /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? = nil, - thrownError: ThrownTypeClauseSyntax? = nil, - _ unexpectedAfterThrownError: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? = nil, + throwsClause: ThrowsClauseSyntax? = nil, + _ unexpectedAfterThrowsClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -563,20 +559,16 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L self = withExtendedLifetime((SyntaxArena(), ( unexpectedBeforeAsyncSpecifier, asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndThrownError, - thrownError, - unexpectedAfterThrownError + unexpectedBetweenAsyncSpecifierAndThrowsClause, + throwsClause, + unexpectedAfterThrowsClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, - throwsSpecifier?.raw, - unexpectedBetweenThrowsSpecifierAndThrownError?.raw, - thrownError?.raw, - unexpectedAfterThrownError?.raw + unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw, + throwsClause?.raw, + unexpectedAfterThrowsClause?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorEffectSpecifiers, @@ -613,7 +605,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } @@ -622,21 +614,17 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - /// The `throws` keyword. - /// - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be `throws`. - public var throwsSpecifier: TokenSyntax? { + /// The clause specifying thrown errors + public var throwsClause: ThrowsClauseSyntax? { get { - return Syntax(self).child(at: 3)?.cast(TokenSyntax.self) + return Syntax(self).child(at: 3)?.cast(ThrowsClauseSyntax.self) } set(value) { self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(AccessorEffectSpecifiersSyntax.self) } } - public var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { + public var unexpectedAfterThrowsClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -645,35 +633,13 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - /// The specific error type thrown by this accessor. - @_spi(ExperimentalLanguageFeatures) - public var thrownError: ThrownTypeClauseSyntax? { - get { - return Syntax(self).child(at: 5)?.cast(ThrownTypeClauseSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(AccessorEffectSpecifiersSyntax.self) - } - } - - public var unexpectedAfterThrownError: UnexpectedNodesSyntax? { - get { - return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(AccessorEffectSpecifiersSyntax.self) - } - } - public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, - \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - \Self.throwsSpecifier, - \Self.unexpectedBetweenThrowsSpecifierAndThrownError, - \Self.thrownError, - \Self.unexpectedAfterThrownError + \Self.unexpectedBetweenAsyncSpecifierAndThrowsClause, + \Self.throwsClause, + \Self.unexpectedAfterThrowsClause ]) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index 8eab4d6d8e9..a436eb7f23d 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -3706,8 +3706,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// ### Children /// /// - `asyncSpecifier`: (`async` | `reasync`)? -/// - `throwsSpecifier`: (`throws` | `rethrows`)? -/// - `thrownError`: ``ThrownTypeClauseSyntax``? +/// - `throwsClause`: ``ThrowsClauseSyntax``? /// /// ### Contained in /// @@ -3725,18 +3724,15 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// - Parameters: /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. /// - asyncSpecifier: The `async` or `reasync` keyword. - /// - throwsSpecifier: The `throws` or `rethrows` keyword. - /// - thrownError: The specific error type thrown by this function. + /// - throwsClause: The clause specifying thrown errors /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? = nil, - thrownError: ThrownTypeClauseSyntax? = nil, - _ unexpectedAfterThrownError: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? = nil, + throwsClause: ThrowsClauseSyntax? = nil, + _ unexpectedAfterThrowsClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3745,20 +3741,16 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L self = withExtendedLifetime((SyntaxArena(), ( unexpectedBeforeAsyncSpecifier, asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndThrownError, - thrownError, - unexpectedAfterThrownError + unexpectedBetweenAsyncSpecifierAndThrowsClause, + throwsClause, + unexpectedAfterThrowsClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, - throwsSpecifier?.raw, - unexpectedBetweenThrowsSpecifierAndThrownError?.raw, - thrownError?.raw, - unexpectedAfterThrownError?.raw + unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw, + throwsClause?.raw, + unexpectedAfterThrowsClause?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionEffectSpecifiers, @@ -3797,7 +3789,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } @@ -3806,23 +3798,17 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - /// The `throws` or `rethrows` keyword. - /// - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: - /// - `throws` - /// - `rethrows` - public var throwsSpecifier: TokenSyntax? { + /// The clause specifying thrown errors + public var throwsClause: ThrowsClauseSyntax? { get { - return Syntax(self).child(at: 3)?.cast(TokenSyntax.self) + return Syntax(self).child(at: 3)?.cast(ThrowsClauseSyntax.self) } set(value) { self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(FunctionEffectSpecifiersSyntax.self) } } - public var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { + public var unexpectedAfterThrowsClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -3831,35 +3817,13 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - /// The specific error type thrown by this function. - @_spi(ExperimentalLanguageFeatures) - public var thrownError: ThrownTypeClauseSyntax? { - get { - return Syntax(self).child(at: 5)?.cast(ThrownTypeClauseSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(FunctionEffectSpecifiersSyntax.self) - } - } - - public var unexpectedAfterThrownError: UnexpectedNodesSyntax? { - get { - return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(FunctionEffectSpecifiersSyntax.self) - } - } - public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, - \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - \Self.throwsSpecifier, - \Self.unexpectedBetweenThrowsSpecifierAndThrownError, - \Self.thrownError, - \Self.unexpectedAfterThrownError + \Self.unexpectedBetweenAsyncSpecifierAndThrowsClause, + \Self.throwsClause, + \Self.unexpectedAfterThrowsClause ]) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift index 8abf8e3e7ca..b8097db17e2 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift @@ -468,26 +468,25 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } -// MARK: - ThrownTypeClauseSyntax +// MARK: - ThrowsClauseSyntax -/// The specific error type that a function can throw. -/// /// ### Children /// -/// - `leftParen`: `(` -/// - `type`: ``TypeSyntax`` -/// - `rightParen`: `)` +/// - `throwsSpecifier`: (`throws` | `rethrows`) +/// - `leftParen`: `(`? +/// - `type`: ``TypeSyntax``? +/// - `rightParen`: `)`? /// /// ### Contained in /// -/// - ``AccessorEffectSpecifiersSyntax``.``AccessorEffectSpecifiersSyntax/thrownError`` -/// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/thrownError`` -/// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/thrownError`` -public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +/// - ``AccessorEffectSpecifiersSyntax``.``AccessorEffectSpecifiersSyntax/throwsClause`` +/// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/throwsClause`` +/// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/throwsClause`` +public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: some SyntaxProtocol) { - guard node.raw.kind == .thrownTypeClause else { + guard node.raw.kind == .throwsClause else { return nil } self._syntaxNode = node._syntaxNode @@ -495,18 +494,21 @@ public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta /// - Parameters: /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. - /// - leftParen: The '(' to open the thrown type clause. + /// - throwsSpecifier: The `throws` keyword. + /// - leftParen: The '(' to open the thrown error type specification. /// - type: The thrown error type. - /// - rightParen: The ')' to closure the thrown type clause. + /// - rightParen: The ')' to close the thrown error type specification. /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBeforeThrowsSpecifier: UnexpectedNodesSyntax? = nil, + throwsSpecifier: TokenSyntax, + _ unexpectedBetweenThrowsSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, _ unexpectedBetweenLeftParenAndType: UnexpectedNodesSyntax? = nil, - type: some TypeSyntaxProtocol, + type: (some TypeSyntaxProtocol)? = TypeSyntax?.none, _ unexpectedBetweenTypeAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), + rightParen: TokenSyntax? = nil, _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -514,7 +516,9 @@ public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, + unexpectedBeforeThrowsSpecifier, + throwsSpecifier, + unexpectedBetweenThrowsSpecifierAndLeftParen, leftParen, unexpectedBetweenLeftParenAndType, type, @@ -523,16 +527,18 @@ public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta unexpectedAfterRightParen ))) { (arena, _) in let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, + unexpectedBeforeThrowsSpecifier?.raw, + throwsSpecifier.raw, + unexpectedBetweenThrowsSpecifierAndLeftParen?.raw, + leftParen?.raw, unexpectedBetweenLeftParenAndType?.raw, - type.raw, + type?.raw, unexpectedBetweenTypeAndRightParen?.raw, - rightParen.raw, + rightParen?.raw, unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.thrownTypeClause, + kind: SyntaxKind.throwsClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -543,83 +549,113 @@ public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta } } - public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { + public var unexpectedBeforeThrowsSpecifier: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } - /// The '(' to open the thrown type clause. + /// The `throws` keyword. /// /// ### Tokens /// - /// For syntax trees generated by the parser, this is guaranteed to be `(`. - public var leftParen: TokenSyntax { + /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds: + /// - `throws` + /// - `rethrows` + public var throwsSpecifier: TokenSyntax { get { return Syntax(self).child(at: 1)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } - public var unexpectedBetweenLeftParenAndType: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndLeftParen: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) + } + } + + /// The '(' to open the thrown error type specification. + /// + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `(`. + @_spi(ExperimentalLanguageFeatures) + public var leftParen: TokenSyntax? { + get { + return Syntax(self).child(at: 3)?.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) + } + } + + public var unexpectedBetweenLeftParenAndType: UnexpectedNodesSyntax? { + get { + return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } /// The thrown error type. - public var type: TypeSyntax { + @_spi(ExperimentalLanguageFeatures) + public var type: TypeSyntax? { get { - return Syntax(self).child(at: 3)!.cast(TypeSyntax.self) + return Syntax(self).child(at: 5)?.cast(TypeSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } public var unexpectedBetweenTypeAndRightParen: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } - /// The ')' to closure the thrown type clause. + /// The ')' to close the thrown error type specification. /// /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be `)`. - public var rightParen: TokenSyntax { + @_spi(ExperimentalLanguageFeatures) + public var rightParen: TokenSyntax? { get { - return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) + return Syntax(self).child(at: 7)?.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } public var unexpectedAfterRightParen: UnexpectedNodesSyntax? { get { - return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) + return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) + self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ThrowsClauseSyntax.self) } } public static var structure: SyntaxNodeStructure { return .layout([ - \Self.unexpectedBeforeLeftParen, + \Self.unexpectedBeforeThrowsSpecifier, + \Self.throwsSpecifier, + \Self.unexpectedBetweenThrowsSpecifierAndLeftParen, \Self.leftParen, \Self.unexpectedBetweenLeftParenAndType, \Self.type, @@ -2241,8 +2277,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// ### Children /// /// - `asyncSpecifier`: `async`? -/// - `throwsSpecifier`: `throws`? -/// - `thrownError`: ``ThrownTypeClauseSyntax``? +/// - `throwsClause`: ``ThrowsClauseSyntax``? /// /// ### Contained in /// @@ -2261,17 +2296,15 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS /// - Parameters: /// - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. - /// - thrownError: The specific error type thrown by this function type. + /// - throwsClause: The clause specifying thrown errors /// - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored. public init( leadingTrivia: Trivia? = nil, _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? = nil, - thrownError: ThrownTypeClauseSyntax? = nil, - _ unexpectedAfterThrownError: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? = nil, + throwsClause: ThrowsClauseSyntax? = nil, + _ unexpectedAfterThrowsClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2280,20 +2313,16 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS self = withExtendedLifetime((SyntaxArena(), ( unexpectedBeforeAsyncSpecifier, asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndThrownError, - thrownError, - unexpectedAfterThrownError + unexpectedBetweenAsyncSpecifierAndThrowsClause, + throwsClause, + unexpectedAfterThrowsClause ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, - throwsSpecifier?.raw, - unexpectedBetweenThrowsSpecifierAndThrownError?.raw, - thrownError?.raw, - unexpectedAfterThrownError?.raw + unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw, + throwsClause?.raw, + unexpectedAfterThrowsClause?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeEffectSpecifiers, @@ -2328,7 +2357,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - public var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenAsyncSpecifierAndThrowsClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } @@ -2337,19 +2366,17 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - /// ### Tokens - /// - /// For syntax trees generated by the parser, this is guaranteed to be `throws`. - public var throwsSpecifier: TokenSyntax? { + /// The clause specifying thrown errors + public var throwsClause: ThrowsClauseSyntax? { get { - return Syntax(self).child(at: 3)?.cast(TokenSyntax.self) + return Syntax(self).child(at: 3)?.cast(ThrowsClauseSyntax.self) } set(value) { self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(TypeEffectSpecifiersSyntax.self) } } - public var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { + public var unexpectedAfterThrowsClause: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -2358,35 +2385,13 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - /// The specific error type thrown by this function type. - @_spi(ExperimentalLanguageFeatures) - public var thrownError: ThrownTypeClauseSyntax? { - get { - return Syntax(self).child(at: 5)?.cast(ThrownTypeClauseSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(TypeEffectSpecifiersSyntax.self) - } - } - - public var unexpectedAfterThrownError: UnexpectedNodesSyntax? { - get { - return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) - } - set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(TypeEffectSpecifiersSyntax.self) - } - } - public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeAsyncSpecifier, \Self.asyncSpecifier, - \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - \Self.throwsSpecifier, - \Self.unexpectedBetweenThrowsSpecifierAndThrownError, - \Self.thrownError, - \Self.unexpectedAfterThrownError + \Self.unexpectedBetweenAsyncSpecifierAndThrowsClause, + \Self.throwsClause, + \Self.unexpectedAfterThrowsClause ]) } } From 0e1dcddfa7a8fc3c5844dcfb3359ccbbfc588341 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 12:02:22 -0800 Subject: [PATCH 03/12] Update parser and tests for throws clause changes --- Sources/SwiftParser/Specifiers.swift | 99 +++++++++---------- .../ParseDiagnosticsGenerator.swift | 10 +- Sources/SwiftSyntax/SyntaxProtocol.swift | 11 +-- .../ClosureExprTests.swift | 2 +- .../FunctionSignatureSyntaxTests.swift | 2 +- .../FunctionTypeSyntaxTests.swift | 2 +- .../VariableTests.swift | 2 +- 7 files changed, 59 insertions(+), 69 deletions(-) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index 66f7682616a..5474c9a9db3 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -159,33 +159,27 @@ protocol RawMisplacedEffectSpecifiersTrait { associatedtype CorrectThrowsTokenKinds: TokenSpecSet var asyncSpecifier: RawTokenSyntax? { get } - var throwsSpecifier: RawTokenSyntax? { get } - var thrownError: RawThrownTypeClauseSyntax? { get } + var throwsClause: RawThrowsClauseSyntax? { get } init( asyncSpecifier: RawTokenSyntax?, - throwsSpecifier: RawTokenSyntax?, - thrownError: RawThrownTypeClauseSyntax?, + throwsClause: RawThrowsClauseSyntax?, arena: __shared SyntaxArena ) - func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsKeyword: RawTokenSyntax?, arena: __shared SyntaxArena) -> Self + func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsClause: RawThrowsClauseSyntax?, arena: __shared SyntaxArena) -> Self } protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait { var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get } - var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { get } - var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { get } - var thrownError: RawThrownTypeClauseSyntax? { get } - var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { get } + var unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax? { get } + var unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax? { get } init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax?, asyncSpecifier: RawTokenSyntax?, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax?, - throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax?, - thrownError: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax?, + _ unexpectedBetweenAsyncSpecifierAndThrowsClause: RawUnexpectedNodesSyntax?, + throwsClause: RawThrowsClauseSyntax?, + _ unexpectedAfterThrowsClause: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) } @@ -193,31 +187,26 @@ protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait { extension RawEffectSpecifiersTrait { init( asyncSpecifier: RawTokenSyntax?, - throwsSpecifier: RawTokenSyntax?, - thrownError: RawThrownTypeClauseSyntax?, + throwsClause: RawThrowsClauseSyntax?, arena: __shared SyntaxArena ) { self.init( nil, asyncSpecifier: asyncSpecifier, nil, - throwsSpecifier: throwsSpecifier, - nil, - thrownError: thrownError, + throwsClause: throwsClause, nil, arena: arena ) } - func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsKeyword: RawTokenSyntax?, arena: __shared SyntaxArena) -> Self { + func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsClause: RawThrowsClauseSyntax?, arena: __shared SyntaxArena) -> Self { return Self.init( self.unexpectedBeforeAsyncSpecifier, asyncSpecifier: self.asyncSpecifier ?? misplacedAsyncKeyword, - self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, - throwsSpecifier: self.throwsSpecifier ?? misplacedThrowsKeyword, - self.unexpectedBetweenThrowsSpecifierAndThrownError, - thrownError: thrownError, - self.unexpectedAfterThrownError, + self.unexpectedBetweenAsyncSpecifierAndThrowsClause, + throwsClause: self.throwsClause ?? misplacedThrowsClause, + self.unexpectedAfterThrowsClause, arena: arena ) } @@ -537,13 +526,11 @@ extension RawDeinitializerEffectSpecifiersSyntax: RawMisplacedEffectSpecifiersTr } } - var throwsSpecifier: RawTokenSyntax? { nil } - var thrownError: RawThrownTypeClauseSyntax? { nil } + var throwsClause: RawThrowsClauseSyntax? { nil } init( asyncSpecifier: RawTokenSyntax?, - throwsSpecifier: RawTokenSyntax?, - thrownError: RawThrownTypeClauseSyntax?, + throwsClause: RawThrowsClauseSyntax?, arena: __shared SwiftSyntax.SyntaxArena ) { // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens @@ -551,24 +538,23 @@ extension RawDeinitializerEffectSpecifiersSyntax: RawMisplacedEffectSpecifiersTr // // We don't want to insert missing `throws` for deinit case, // so if `parseMisplacedEffectSpecifiers()` creates one it will be discarded here. - precondition(throwsSpecifier?.isMissing ?? true) + precondition(throwsClause?.throwsSpecifier.isMissing ?? true) self.init( nil, asyncSpecifier: asyncSpecifier, - nil, arena: arena ) } - func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsKeyword: RawTokenSyntax?, arena: SyntaxArena) + func withMisplaced(async misplacedAsyncKeyword: RawTokenSyntax?, throws misplacedThrowsClause: RawThrowsClauseSyntax?, arena: SyntaxArena) -> RawDeinitializerEffectSpecifiersSyntax { - // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens + // `throwsClause` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens // and `CorrectThrowsTokenKinds` is an empty `TokenSpecSet`. // // We don't want to insert missing `throws` for deinit case, // so if `parseMisplacedEffectSpecifiers()` creates one it will be discarded here. - precondition(throwsSpecifier?.isMissing ?? true) + precondition(throwsClause?.throwsSpecifier.isMissing ?? true) return Self.init( self.unexpectedBeforeAsyncSpecifier, asyncSpecifier: self.asyncSpecifier ?? misplacedAsyncKeyword, @@ -596,12 +582,13 @@ extension TokenConsumer { // MARK: - Parsing effect specifiers extension Parser { - private mutating func parseThrownTypeClause() -> RawThrownTypeClauseSyntax { - let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen) + private mutating func parseThrowsClause(after throwsKeyword: RawTokenSyntax) -> RawThrowsClauseSyntax { + let (unexpectedBetweenThrowsSpecifierAndLeftParen, leftParen) = self.expect(.leftParen) let type = self.parseType() let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) - return RawThrownTypeClauseSyntax( - unexpectedBeforeLeftParen, + return RawThrowsClauseSyntax( + throwsSpecifier: throwsKeyword, + unexpectedBetweenThrowsSpecifierAndLeftParen, leftParen: leftParen, type: type, unexpectedBeforeRightParen, @@ -615,8 +602,8 @@ extension Parser { var asyncKeyword: RawTokenSyntax? = nil var unexpectedBeforeThrows: [RawSyntax] = [] var throwsKeyword: RawTokenSyntax? - var thrownError: RawThrownTypeClauseSyntax? - var unexpectedAfterThrownError: [RawSyntax] = [] + var throwsClause: RawThrowsClauseSyntax? + var unexpectedAfterThrowsClause: [RawSyntax] = [] while let misspelledAsync = self.consume(ifAnyIn: S.MisspelledAsyncTokenKinds.self) { unexpectedBeforeAsync.append(RawSyntax(misspelledAsync)) @@ -654,7 +641,7 @@ extension Parser { throwsKeyword = throwsKw if self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { - thrownError = parseThrownTypeClause() + throwsClause = parseThrowsClause(after: throwsKw) } } @@ -662,33 +649,36 @@ extension Parser { while self.hasProgressed(&unexpectedAfterThrownErrorLoopProgress) { if let (_, handle, _) = self.at(anyIn: S.MisspelledAsyncTokenKinds.self, or: S.CorrectAsyncTokenKinds.self) { let misspelledAsync = self.eat(handle) - unexpectedAfterThrownError.append(RawSyntax(misspelledAsync)) + unexpectedAfterThrowsClause.append(RawSyntax(misspelledAsync)) if asyncKeyword == nil { // Handle `async` after `throws` asyncKeyword = missingToken(.keyword(.async)) } } else if let (_, handle, _) = self.at(anyIn: S.MisspelledThrowsTokenKinds.self, or: S.CorrectThrowsTokenKinds.self) { let misspelledThrows = self.eat(handle) - unexpectedAfterThrownError.append(RawSyntax(misspelledThrows)) + unexpectedAfterThrowsClause.append(RawSyntax(misspelledThrows)) } else { break } } - if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && thrownError == nil - && unexpectedAfterThrownError.isEmpty + if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && throwsClause == nil + && unexpectedAfterThrowsClause.isEmpty { return nil } + // If needed, form a throws clause from just the throws keyword. + throwsClause = throwsClause ?? throwsKeyword.map { + RawThrowsClauseSyntax(throwsSpecifier: $0, leftParen: nil, type: nil, rightParen: nil, arena: self.arena) + } + return S( RawUnexpectedNodesSyntax(unexpectedBeforeAsync, arena: self.arena), asyncSpecifier: asyncKeyword, RawUnexpectedNodesSyntax(unexpectedBeforeThrows, arena: self.arena), - throwsSpecifier: throwsKeyword, - nil, - thrownError: thrownError, - RawUnexpectedNodesSyntax(unexpectedAfterThrownError, arena: self.arena), + throwsClause: throwsClause, + RawUnexpectedNodesSyntax(unexpectedAfterThrowsClause, arena: self.arena), arena: self.arena ) } @@ -774,7 +764,7 @@ extension Parser { } else if let (spec, handle, matchedSubset) = self.at(anyIn: S.MisspelledThrowsTokenKinds.self, or: S.CorrectThrowsTokenKinds.self) { let misspelledThrows = self.eat(handle) unexpected.append(misspelledThrows) - if effectSpecifiers?.throwsSpecifier == nil { + if effectSpecifiers?.throwsClause == nil { if matchedSubset == S.CorrectThrowsTokenKinds.self { synthesizedThrows = missingToken(spec) } else { @@ -786,13 +776,16 @@ extension Parser { } } if synthesizedAsync != nil || synthesizedThrows != nil { + let synthesizedThrowsClause = synthesizedThrows.map { + RawThrowsClauseSyntax(throwsSpecifier: $0, leftParen: nil, type: nil, rightParen: nil, arena: self.arena) + } + if let specifiers = effectSpecifiers { - effectSpecifiers = specifiers.withMisplaced(async: synthesizedAsync, throws: synthesizedThrows, arena: self.arena) + effectSpecifiers = specifiers.withMisplaced(async: synthesizedAsync, throws: synthesizedThrowsClause, arena: self.arena) } else { effectSpecifiers = S( asyncSpecifier: synthesizedAsync, - throwsSpecifier: synthesizedThrows, - thrownError: nil, + throwsClause: synthesizedThrowsClause, arena: self.arena ) } diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index 0c5c45bd40f..a5f56c4ecb3 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -236,7 +236,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { exchangeTokens( unexpected: misplacedSpecifiers, unexpectedTokenCondition: { EffectSpecifier(token: $0) != nil }, - correctTokens: [effectSpecifiers?.asyncSpecifier, effectSpecifiers?.throwsSpecifier], + correctTokens: [effectSpecifiers?.asyncSpecifier, effectSpecifiers?.throwsClause?.throwsSpecifier], message: { EffectsSpecifierAfterArrow(effectsSpecifiersAfterArrow: $0) }, moveFixIt: { MoveTokensInFrontOfFixIt(movedTokens: $0, inFrontOf: .arrow) }, removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) } @@ -255,12 +255,12 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { let specifierInfo = [ (node.asyncSpecifier, { AsyncEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledAsync), - (node.throwsSpecifier, { ThrowsEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledThrows), + (node.throwsClause?.throwsSpecifier, { ThrowsEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledThrows), ] let unexpectedNodes = [ - node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedBetweenThrowsSpecifierAndThrownError, - node.unexpectedAfterThrownError, + node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsClause, + node.unexpectedAfterThrowsClause, ] // Diagnostics that are emitted later silence previous diagnostics, so check @@ -284,7 +284,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { if let throwsSpecifier = node.throwsSpecifier { exchangeTokens( - unexpected: node.unexpectedAfterThrownError, + unexpected: node.unexpectedAfterThrowsClause, unexpectedTokenCondition: { AsyncEffectSpecifier(token: $0) != nil }, correctTokens: [node.asyncSpecifier], message: { AsyncMustPrecedeThrows(asyncKeywords: $0, throwsKeyword: throwsSpecifier) }, diff --git a/Sources/SwiftSyntax/SyntaxProtocol.swift b/Sources/SwiftSyntax/SyntaxProtocol.swift index 4959bb84cb4..47a6edae71c 100644 --- a/Sources/SwiftSyntax/SyntaxProtocol.swift +++ b/Sources/SwiftSyntax/SyntaxProtocol.swift @@ -736,12 +736,9 @@ public extension SyntaxChildChoices { } } -extension EffectSpecifiersSyntax { - // Default implementation for the experimental thrownError child, which must - // be provided due to the use of @_spi. - @_spi(ExperimentalLanguageFeatures) - public var thrownError: ThrownTypeClauseSyntax? { - get { return nil } - set {} +public extension EffectSpecifiersSyntax { + /// Retrieve the throws specifier, ignoring any thrown error type. + var throwsSpecifier: TokenSyntax? { + throwsClause?.throwsSpecifier } } diff --git a/Tests/SwiftSyntaxBuilderTest/ClosureExprTests.swift b/Tests/SwiftSyntaxBuilderTest/ClosureExprTests.swift index 2abfe584626..0894815e2c3 100644 --- a/Tests/SwiftSyntaxBuilderTest/ClosureExprTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/ClosureExprTests.swift @@ -44,7 +44,7 @@ final class ClosureExprTests: XCTestCase { ), effectSpecifiers: TypeEffectSpecifiersSyntax( asyncSpecifier: .keyword(.async), - throwsSpecifier: .keyword(.throws) + throwsClause: ThrowsClauseSyntax(throwsSpecifier: .keyword(.throws)) ) ) ) {} diff --git a/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift index 4398988656d..8b6687100dd 100644 --- a/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift @@ -16,7 +16,7 @@ import XCTest final class FunctionSignatureSyntaxTests: XCTestCase { func testFunctionEffectSpecifiersSyntax() throws { - let functionEffects = FunctionEffectSpecifiersSyntax(asyncSpecifier: .keyword(.async), throwsSpecifier: .keyword(.rethrows)) + let functionEffects = FunctionEffectSpecifiersSyntax(asyncSpecifier: .keyword(.async), throwsClause: ThrowsClauseSyntax(throwsSpecifier: .keyword(.rethrows))) let buildable = FunctionSignatureSyntax( parameterClause: .init(parameters: []), effectSpecifiers: functionEffects, diff --git a/Tests/SwiftSyntaxBuilderTest/FunctionTypeSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/FunctionTypeSyntaxTests.swift index 8dfe1f9fd0a..4c20c041124 100644 --- a/Tests/SwiftSyntaxBuilderTest/FunctionTypeSyntaxTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/FunctionTypeSyntaxTests.swift @@ -16,7 +16,7 @@ import XCTest final class FunctionTypeSyntaxTests: XCTestCase { func testFunctionEffectSpecifiersSyntax() throws { - let typeEffects = TypeEffectSpecifiersSyntax(asyncSpecifier: .keyword(.async), throwsSpecifier: .keyword(.throws)) + let typeEffects = TypeEffectSpecifiersSyntax(asyncSpecifier: .keyword(.async), throwsClause: ThrowsClauseSyntax(throwsSpecifier: .keyword(.throws))) let buildable = FunctionTypeSyntax( parameters: [], effectSpecifiers: typeEffects, diff --git a/Tests/SwiftSyntaxBuilderTest/VariableTests.swift b/Tests/SwiftSyntaxBuilderTest/VariableTests.swift index f0b5079eaaf..9c384a1f470 100644 --- a/Tests/SwiftSyntaxBuilderTest/VariableTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/VariableTests.swift @@ -302,7 +302,7 @@ final class VariableTests: XCTestCase { accessorSpecifier: .keyword(.get), effectSpecifiers: AccessorEffectSpecifiersSyntax( asyncSpecifier: .keyword(.async), - throwsSpecifier: .keyword(.throws) + throwsClause: ThrowsClauseSyntax(throwsSpecifier: .keyword(.throws)) ) ) {} } From c0e763c38b3ba34d8a982502fd7bc7e91d8e7bed Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 12:08:37 -0800 Subject: [PATCH 04/12] Add release note for the introduction of the throws clause --- Release Notes/511.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Release Notes/511.md b/Release Notes/511.md index bcc3542a0ed..b2a714888a9 100644 --- a/Release Notes/511.md +++ b/Release Notes/511.md @@ -28,6 +28,10 @@ - Description: `CodeBlockSyntax` is now `SyntaxParseable`, so it can be used with string interpolations. - Pull Request: https://github.com/apple/swift-syntax/pull/2361 +- `ThrowsClause` + - Description: The `throwsSpecifier` for the effects nodes (`AccessorEffectSpecifiers`, `FunctionEffectSpecifiers`, `TypeEffectSpecifiers`, `EffectSpecifiers`) has been replaced with `throwsClause`, which captures both the throws specifier and the (optional) thrown error type, as introduced by SE-0413. + - Pull Request: TBD + ## API Behavior Changes ## Deprecations From 73c1ce979ca515039f81d7cc01dc697bf41b16ab Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 12:16:07 -0800 Subject: [PATCH 05/12] Reformat --- CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift | 2 +- Sources/SwiftParser/Specifiers.swift | 8 +++++--- .../FunctionSignatureSyntaxTests.swift | 5 ++++- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index ea233325fb6..cc440945bc1 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -172,7 +172,7 @@ public let COMMON_NODES: [Node] = [ kind: .token(choices: [.keyword(.async)]), documentation: "The `async` keyword.", isOptional: true - ), + ) ] ), diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index 5474c9a9db3..69a68029165 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -669,9 +669,11 @@ extension Parser { } // If needed, form a throws clause from just the throws keyword. - throwsClause = throwsClause ?? throwsKeyword.map { - RawThrowsClauseSyntax(throwsSpecifier: $0, leftParen: nil, type: nil, rightParen: nil, arena: self.arena) - } + throwsClause = + throwsClause + ?? throwsKeyword.map { + RawThrowsClauseSyntax(throwsSpecifier: $0, leftParen: nil, type: nil, rightParen: nil, arena: self.arena) + } return S( RawUnexpectedNodesSyntax(unexpectedBeforeAsync, arena: self.arena), diff --git a/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift index 8b6687100dd..7b9cd54261b 100644 --- a/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/FunctionSignatureSyntaxTests.swift @@ -16,7 +16,10 @@ import XCTest final class FunctionSignatureSyntaxTests: XCTestCase { func testFunctionEffectSpecifiersSyntax() throws { - let functionEffects = FunctionEffectSpecifiersSyntax(asyncSpecifier: .keyword(.async), throwsClause: ThrowsClauseSyntax(throwsSpecifier: .keyword(.rethrows))) + let functionEffects = FunctionEffectSpecifiersSyntax( + asyncSpecifier: .keyword(.async), + throwsClause: ThrowsClauseSyntax(throwsSpecifier: .keyword(.rethrows)) + ) let buildable = FunctionSignatureSyntax( parameterClause: .init(parameters: []), effectSpecifiers: functionEffects, From 7eaee714f18bf2c93ea8be418658d1768aafa71d Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 12:17:57 -0800 Subject: [PATCH 06/12] Add pull request number to release note --- Release Notes/511.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Release Notes/511.md b/Release Notes/511.md index b2a714888a9..4f83eda9ed0 100644 --- a/Release Notes/511.md +++ b/Release Notes/511.md @@ -30,7 +30,7 @@ - `ThrowsClause` - Description: The `throwsSpecifier` for the effects nodes (`AccessorEffectSpecifiers`, `FunctionEffectSpecifiers`, `TypeEffectSpecifiers`, `EffectSpecifiers`) has been replaced with `throwsClause`, which captures both the throws specifier and the (optional) thrown error type, as introduced by SE-0413. - - Pull Request: TBD + - Pull Request: https://github.com/apple/swift-syntax/pull/2379 ## API Behavior Changes From 3fe699772de4383c52493e09c5a7591805795c76 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 15:19:04 -0800 Subject: [PATCH 07/12] Improve compatibility shims for throws clause refactoring --- .../SwiftSyntaxCompatibility.swift | 26 +++++++++++++++++++ Sources/SwiftSyntax/SyntaxProtocol.swift | 7 ----- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift index 2af9197c7db..9b540d09165 100644 --- a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift +++ b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift @@ -50,6 +50,32 @@ public extension DeclGroupSyntax { } } + +public extension EffectSpecifiersSyntax { + @available(*, deprecated, message: "use throwsClause.throwsSpecifier") + var throwsSpecifier: TokenSyntax? { + throwsClause?.throwsSpecifier + } +} + + +public extension FunctionEffectSpecifiersSyntax { + @available(*, deprecated, message: "use throwsClause instead of throwsSpecifier") + init( + leadingTrivia: Trivia? = nil, + asyncSpecifier: TokenSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + asyncSpecifier: asyncSpecifier, + throwsClause: throwsSpecifier.map { ThrowsClauseSyntax(throwsSpecifier: $0) }, + trailingTrivia: trailingTrivia + ) + } +} + public extension FreestandingMacroExpansionSyntax { @available(*, deprecated, renamed: "pound") var poundToken: TokenSyntax { diff --git a/Sources/SwiftSyntax/SyntaxProtocol.swift b/Sources/SwiftSyntax/SyntaxProtocol.swift index 47a6edae71c..b96c2508079 100644 --- a/Sources/SwiftSyntax/SyntaxProtocol.swift +++ b/Sources/SwiftSyntax/SyntaxProtocol.swift @@ -735,10 +735,3 @@ public extension SyntaxChildChoices { return self.as(S.self)! } } - -public extension EffectSpecifiersSyntax { - /// Retrieve the throws specifier, ignoring any thrown error type. - var throwsSpecifier: TokenSyntax? { - throwsClause?.throwsSpecifier - } -} From d0a35c5c49636160883c749cdcf240893f894468 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 15:20:21 -0800 Subject: [PATCH 08/12] Switch to throwsClause API for macro example --- .../MacroExamples/Implementation/Peer/AddAsyncMacro.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Examples/Sources/MacroExamples/Implementation/Peer/AddAsyncMacro.swift b/Examples/Sources/MacroExamples/Implementation/Peer/AddAsyncMacro.swift index e30eb37b98a..2f9011368b9 100644 --- a/Examples/Sources/MacroExamples/Implementation/Peer/AddAsyncMacro.swift +++ b/Examples/Sources/MacroExamples/Implementation/Peer/AddAsyncMacro.swift @@ -127,7 +127,7 @@ public struct AddAsyncMacro: PeerMacro { funcDecl.signature.effectSpecifiers = FunctionEffectSpecifiersSyntax( leadingTrivia: .space, asyncSpecifier: .keyword(.async), - throwsSpecifier: isResultReturn ? .keyword(.throws) : nil + throwsClause: isResultReturn ? ThrowsClauseSyntax(throwsSpecifier: .keyword(.throws)) : nil ) // add result type From 0be9c6209cc23e181073a4c819760f117dcd6da3 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 22:14:42 -0800 Subject: [PATCH 09/12] Fix formatting --- Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift index 9b540d09165..b0184f858ab 100644 --- a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift +++ b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift @@ -50,7 +50,6 @@ public extension DeclGroupSyntax { } } - public extension EffectSpecifiersSyntax { @available(*, deprecated, message: "use throwsClause.throwsSpecifier") var throwsSpecifier: TokenSyntax? { @@ -58,14 +57,13 @@ public extension EffectSpecifiersSyntax { } } - public extension FunctionEffectSpecifiersSyntax { @available(*, deprecated, message: "use throwsClause instead of throwsSpecifier") init( - leadingTrivia: Trivia? = nil, - asyncSpecifier: TokenSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - trailingTrivia: Trivia? = nil + leadingTrivia: Trivia? = nil, + asyncSpecifier: TokenSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + trailingTrivia: Trivia? = nil ) { self.init( leadingTrivia: leadingTrivia, From 67b81238d791cea4996477a79da08592dad69c8d Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 22:40:48 -0800 Subject: [PATCH 10/12] Improve EffectSpecifiersSyntax.throwsSpecifier compatibility property --- .../SwiftSyntax/SwiftSyntaxCompatibility.swift | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift index b0184f858ab..e1ec7a35f92 100644 --- a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift +++ b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift @@ -53,7 +53,20 @@ public extension DeclGroupSyntax { public extension EffectSpecifiersSyntax { @available(*, deprecated, message: "use throwsClause.throwsSpecifier") var throwsSpecifier: TokenSyntax? { - throwsClause?.throwsSpecifier + get { throwsClause?.throwsSpecifier } + + set { + guard let newSpecifier = newValue else { + throwsClause = nil + return + } + + if let throwsClause { + self.throwsClause = throwsClause.with(\.throwsSpecifier, newSpecifier) + } else { + self.throwsClause = ThrowsClauseSyntax(throwsSpecifier: newSpecifier) + } + } } } From b1767acdccc6cde5f67c001114eecd6d4a6f48b6 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 22:46:13 -0800 Subject: [PATCH 11/12] Add compatibility inits for remaining effects nodes --- .../SwiftSyntaxCompatibility.swift | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift index e1ec7a35f92..ad6c53b3e91 100644 --- a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift +++ b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift @@ -13,6 +13,23 @@ // This file provides compatibility aliases to keep dependents of SwiftSyntax building. // All users of the declarations in this file should transition away from them ASAP. +public extension AccessorEffectSpecifiersSyntax { + @available(*, deprecated, message: "use throwsClause instead of throwsSpecifier") + init( + leadingTrivia: Trivia? = nil, + asyncSpecifier: TokenSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + asyncSpecifier: asyncSpecifier, + throwsClause: throwsSpecifier.map { ThrowsClauseSyntax(throwsSpecifier: $0) }, + trailingTrivia: trailingTrivia + ) + } +} + extension AttributeSyntax { @available(*, deprecated, renamed: "Arguments") public typealias Argument = Arguments @@ -475,6 +492,23 @@ public extension TokenSyntax { } } +public extension TypeEffectSpecifiersSyntax { + @available(*, deprecated, message: "use throwsClause instead of throwsSpecifier") + init( + leadingTrivia: Trivia? = nil, + asyncSpecifier: TokenSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { + self.init( + leadingTrivia: leadingTrivia, + asyncSpecifier: asyncSpecifier, + throwsClause: throwsSpecifier.map { ThrowsClauseSyntax(throwsSpecifier: $0) }, + trailingTrivia: trailingTrivia + ) + } +} + //==========================================================================// // IMPORTANT: If you are tempted to add a compatibility layer code here // // please insert it in alphabetical order above // From ebd8e2e2f6b06ba71bc502da45071d67a813fd2a Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 1 Dec 2023 23:24:14 -0800 Subject: [PATCH 12/12] Clean up parsing of effect specifiers a bit Teach `parseThrowsClause(after:)` to check for the `(` itself, so we have just the one place where we deal with the presence or absence of the thrown error type specification. --- Sources/SwiftParser/Specifiers.swift | 30 ++++++++++++++-------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index 69a68029165..193eaf65dd3 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -582,7 +582,18 @@ extension TokenConsumer { // MARK: - Parsing effect specifiers extension Parser { + /// Parse a throws clause after we've already parsed the 'throws' keyword to introduce it. private mutating func parseThrowsClause(after throwsKeyword: RawTokenSyntax) -> RawThrowsClauseSyntax { + guard self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) else { + return RawThrowsClauseSyntax( + throwsSpecifier: throwsKeyword, + leftParen: nil, + type: nil, + rightParen: nil, + arena: self.arena + ) + } + let (unexpectedBetweenThrowsSpecifierAndLeftParen, leftParen) = self.expect(.leftParen) let type = self.parseType() let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) @@ -601,7 +612,6 @@ extension Parser { var unexpectedBeforeAsync: [RawSyntax] = [] var asyncKeyword: RawTokenSyntax? = nil var unexpectedBeforeThrows: [RawSyntax] = [] - var throwsKeyword: RawTokenSyntax? var throwsClause: RawThrowsClauseSyntax? var unexpectedAfterThrowsClause: [RawSyntax] = [] @@ -625,10 +635,10 @@ extension Parser { unexpectedBeforeThrows.append(RawSyntax(misspelledAsync)) } else if let misspelledThrows = self.consume(ifAnyIn: S.MisspelledThrowsTokenKinds.self) { unexpectedBeforeThrows.append(RawSyntax(misspelledThrows)) - if throwsKeyword == nil { + if throwsClause == nil { // Let's synthesize a missing 'throws'. If we find a real throws specifier // later, we will replace the missing token by the present token. - throwsKeyword = missingToken(.keyword(.throws)) + throwsClause = RawThrowsClauseSyntax(throwsSpecifier: missingToken(.keyword(.throws)), leftParen: nil, type: nil, rightParen: nil, arena: self.arena) } } else { break @@ -638,11 +648,8 @@ extension Parser { if let (_, handle) = self.canRecoverTo(anyIn: S.CorrectThrowsTokenKinds.self) { let (unexpected, throwsKw) = self.eat(handle) unexpectedBeforeThrows.append(contentsOf: unexpected?.elements ?? []) - throwsKeyword = throwsKw - if self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { - throwsClause = parseThrowsClause(after: throwsKw) - } + throwsClause = parseThrowsClause(after: throwsKw) } var unexpectedAfterThrownErrorLoopProgress = LoopProgressCondition() @@ -662,19 +669,12 @@ extension Parser { } } - if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && throwsClause == nil + if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsClause == nil && unexpectedAfterThrowsClause.isEmpty { return nil } - // If needed, form a throws clause from just the throws keyword. - throwsClause = - throwsClause - ?? throwsKeyword.map { - RawThrowsClauseSyntax(throwsSpecifier: $0, leftParen: nil, type: nil, rightParen: nil, arena: self.arena) - } - return S( RawUnexpectedNodesSyntax(unexpectedBeforeAsync, arena: self.arena), asyncSpecifier: asyncKeyword,