From 8e755843e3e93d542b4279f29f6310c42a01d448 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Sat, 16 Sep 2023 21:45:02 -0700 Subject: [PATCH 01/17] [Typed throws] Add thrown type to effect specifiers --- .../Sources/SyntaxSupport/CommonNodes.swift | 36 +++++++++++++++++++ .../SyntaxSupport/SyntaxNodeKind.swift | 1 + .../Sources/SyntaxSupport/Traits.swift | 8 ++++- 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index c0bf68d4bd5..8876e6e67d8 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -79,6 +79,27 @@ public let COMMON_NODES: [Node] = [ ] ), + Node( + kind: .thrownType, + base: .syntax, + nameForDiagnostics: "thrown type", + children: [ + Child( + name: "leftParen", + kind: .token(choices: [.token(.leftParen)]) + ), + Child( + name: "type", + kind: .node(kind: .type), + nameForDiagnostics: "type" + ), + Child( + name: "rightParen", + kind: .token(choices: [.token(.rightParen)]) + ), + ] + ), + Node( kind: .accessorEffectSpecifiers, base: .syntax, @@ -99,6 +120,11 @@ public let COMMON_NODES: [Node] = [ documentation: "The `throws` keyword.", isOptional: true ), + Child( + name: "thrownType", + kind: .node(kind: .thrownType), + isOptional: true + ), ] ), @@ -122,6 +148,11 @@ public let COMMON_NODES: [Node] = [ documentation: "The `throws` or `rethrows` keyword.", isOptional: true ), + Child( + name: "thrownType", + kind: .node(kind: .thrownType), + isOptional: true + ), ] ), @@ -324,6 +355,11 @@ public let COMMON_NODES: [Node] = [ kind: .token(choices: [.keyword(.throws)]), isOptional: true ), + Child( + name: "thrownType", + kind: .node(kind: .thrownType), + isOptional: true + ), ] ), diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index c5613534ec8..731f84fa56e 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -268,6 +268,7 @@ public enum SyntaxNodeKind: String, CaseIterable { case switchExpr case ternaryExpr case thenStmt + case thrownType case throwStmt case tryExpr case tupleExpr diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index e889de2b701..c8062f07149 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -56,7 +56,13 @@ public let TRAITS: [Trait] = [ 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: "unexpectedAfterThrowsSpecifier", kind: .node(kind: .unexpectedNodes), isOptional: true), + Child(name: "unexpectedBetweenThrowsSpecifierAndThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), + Child( + name: "thrownType", + kind: .node(kind: .thrownType), + isOptional: true + ), + Child(name: "unexpectedAfterThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), ] ), Trait( From a602fddf0fb3bc6fccfc7a75710ae24091fd6803 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 22 Sep 2023 12:07:15 -0700 Subject: [PATCH 02/17] Regenerate syntax tree --- .../generated/ChildNameForDiagnostics.swift | 2 + .../SyntaxKindNameForDiagnostics.swift | 2 + .../generated/SwiftSyntax.md | 1 + .../generated/ChildNameForKeyPath.swift | 38 +++- .../generated/SyntaxAnyVisitor.swift | 8 + .../generated/SyntaxBaseNodes.swift | 1 + .../SwiftSyntax/generated/SyntaxEnum.swift | 3 + .../SwiftSyntax/generated/SyntaxKind.swift | 3 + .../generated/SyntaxRewriter.swift | 13 ++ .../SwiftSyntax/generated/SyntaxTraits.swift | 12 +- .../generated/SyntaxTransform.swift | 14 ++ .../SwiftSyntax/generated/SyntaxVisitor.swift | 18 ++ .../generated/raw/RawSyntaxNodesAB.swift | 20 +- .../generated/raw/RawSyntaxNodesEF.swift | 20 +- .../generated/raw/RawSyntaxNodesTUVWXYZ.swift | 102 +++++++++- .../generated/raw/RawSyntaxValidation.swift | 21 +- .../generated/syntaxNodes/SyntaxNodesAB.swift | 37 +++- .../generated/syntaxNodes/SyntaxNodesEF.swift | 37 +++- .../syntaxNodes/SyntaxNodesTUVWXYZ.swift | 189 +++++++++++++++++- 19 files changed, 504 insertions(+), 37 deletions(-) diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index 2644f78ef3e..fde1020ab03 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -332,6 +332,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "first choice" case \TernaryExprSyntax.elseExpression: return "second choice" + case \ThrownTypeSyntax.type: + return "type" case \TuplePatternElementSyntax.label: return "label" case \TupleTypeElementSyntax.firstName: diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index 64ff8b4cadd..a2f476a6bba 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -361,6 +361,8 @@ extension SyntaxKind { return "'then' statement" case .throwStmt: return "'throw' statement" + case .thrownType: + return "thrown type" 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 221e4db6b67..586d2074b4b 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -380,6 +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 4cc8070057c..3422f1ce69c 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -65,8 +65,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" case \AccessorEffectSpecifiersSyntax.throwsSpecifier: return "throwsSpecifier" - case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier: - return "unexpectedAfterThrowsSpecifier" + case \AccessorEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType: + return "unexpectedBetweenThrowsSpecifierAndThrownType" + case \AccessorEffectSpecifiersSyntax.thrownType: + return "thrownType" + case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrownType: + return "unexpectedAfterThrownType" case \AccessorParametersSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \AccessorParametersSyntax.leftParen: @@ -1401,8 +1405,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" case \FunctionEffectSpecifiersSyntax.throwsSpecifier: return "throwsSpecifier" - case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier: - return "unexpectedAfterThrowsSpecifier" + case \FunctionEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType: + return "unexpectedBetweenThrowsSpecifierAndThrownType" + case \FunctionEffectSpecifiersSyntax.thrownType: + return "thrownType" + case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrownType: + return "unexpectedAfterThrownType" case \FunctionParameterClauseSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \FunctionParameterClauseSyntax.leftParen: @@ -3083,6 +3091,20 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "expression" case \ThrowStmtSyntax.unexpectedAfterExpression: return "unexpectedAfterExpression" + case \ThrownTypeSyntax.unexpectedBeforeLeftParen: + return "unexpectedBeforeLeftParen" + case \ThrownTypeSyntax.leftParen: + return "leftParen" + case \ThrownTypeSyntax.unexpectedBetweenLeftParenAndType: + return "unexpectedBetweenLeftParenAndType" + case \ThrownTypeSyntax.type: + return "type" + case \ThrownTypeSyntax.unexpectedBetweenTypeAndRightParen: + return "unexpectedBetweenTypeAndRightParen" + case \ThrownTypeSyntax.rightParen: + return "rightParen" + case \ThrownTypeSyntax.unexpectedAfterRightParen: + return "unexpectedAfterRightParen" case \TryExprSyntax.unexpectedBeforeTryKeyword: return "unexpectedBeforeTryKeyword" case \TryExprSyntax.tryKeyword: @@ -3235,8 +3257,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" case \TypeEffectSpecifiersSyntax.throwsSpecifier: return "throwsSpecifier" - case \TypeEffectSpecifiersSyntax.unexpectedAfterThrowsSpecifier: - return "unexpectedAfterThrowsSpecifier" + case \TypeEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType: + return "unexpectedBetweenThrowsSpecifierAndThrownType" + case \TypeEffectSpecifiersSyntax.thrownType: + return "thrownType" + case \TypeEffectSpecifiersSyntax.unexpectedAfterThrownType: + return "unexpectedAfterThrownType" case \TypeExprSyntax.unexpectedBeforeType: return "unexpectedBeforeType" case \TypeExprSyntax.type: diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index be3ea0fe3ce..fa6ca054546 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -2022,6 +2022,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } + override open func visit(_ node: ThrownTypeSyntax) -> SyntaxVisitorContinueKind { + return visitAny(node._syntaxNode) + } + + override open func visitPost(_ node: ThrownTypeSyntax) { + visitAnyPost(node._syntaxNode) + } + override open func visit(_ node: TryExprSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index 7fe243fef78..fc6738f3808 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -1769,6 +1769,7 @@ extension Syntax { .node(TernaryExprSyntax.self), .node(ThenStmtSyntax.self), .node(ThrowStmtSyntax.self), + .node(ThrownTypeSyntax.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 f2889f628b3..8d28f6ec36b 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -263,6 +263,7 @@ public enum SyntaxEnum { #endif case thenStmt(ThenStmtSyntax) case throwStmt(ThrowStmtSyntax) + case thrownType(ThrownTypeSyntax) case tryExpr(TryExprSyntax) case tupleExpr(TupleExprSyntax) case tuplePatternElementList(TuplePatternElementListSyntax) @@ -792,6 +793,8 @@ public extension Syntax { return .thenStmt(ThenStmtSyntax(self)!) case .throwStmt: return .throwStmt(ThrowStmtSyntax(self)!) + case .thrownType: + return .thrownType(ThrownTypeSyntax(self)!) case .tryExpr: return .tryExpr(TryExprSyntax(self)!) case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index 05c2fc16d70..c5d4e0944d5 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -263,6 +263,7 @@ public enum SyntaxKind: CaseIterable { #endif case thenStmt case throwStmt + case thrownType case tryExpr case tupleExpr case tuplePatternElementList @@ -913,6 +914,8 @@ public enum SyntaxKind: CaseIterable { return ThenStmtSyntax.self case .throwStmt: return ThrowStmtSyntax.self + case .thrownType: + return ThrownTypeSyntax.self case .tryExpr: return TryExprSyntax.self case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index b34aa7261b9..5e825731002 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1798,6 +1798,13 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } + /// Visit a ``ThrownTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ThrownTypeSyntax) -> ThrownTypeSyntax { + return visitChildren(node) + } + /// Visit a ``TryExprSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node @@ -3079,6 +3086,10 @@ open class SyntaxRewriter { return { self.visitImpl($0, ThrowStmtSyntax.self, self.visit) } + case .thrownType: + return { + self.visitImpl($0, ThrownTypeSyntax.self, self.visit) + } case .tryExpr: return { self.visitImpl($0, TryExprSyntax.self, self.visit) @@ -3703,6 +3714,8 @@ open class SyntaxRewriter { return visitImpl(node, ThenStmtSyntax.self, visit) case .throwStmt: return visitImpl(node, ThrowStmtSyntax.self, visit) + case .thrownType: + return visitImpl(node, ThrownTypeSyntax.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 d9bb2a2bf18..b69130f0961 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -152,7 +152,17 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { + var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { + get + set + } + + var thrownType: ThrownTypeSyntax? { + get + set + } + + var unexpectedAfterThrownType: UnexpectedNodesSyntax? { get set } diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index 64a874c359e..cd774a8d363 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -1240,6 +1240,11 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ThrowStmtSyntax) -> ResultType + /// Visiting ``ThrownTypeSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: the sum of whatever the child visitors return. + func visit(_ node: ThrownTypeSyntax) -> ResultType + /// Visiting ``TryExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. @@ -3119,6 +3124,13 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } + /// Visiting ``ThrownTypeSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: nil by default. + public func visit(_ node: ThrownTypeSyntax) -> ResultType { + visitAny(Syntax(node)) + } + /// Visiting ``TryExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. @@ -3830,6 +3842,8 @@ extension SyntaxTransformVisitor { return visit(derived) case .throwStmt(let derived): return visit(derived) + case .thrownType(let derived): + return visit(derived) case .tryExpr(let derived): return visit(derived) case .tupleExpr(let derived): diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index 07255c2c364..a6063a2552d 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -2980,6 +2980,18 @@ open class SyntaxVisitor { open func visitPost(_ node: ThrowStmtSyntax) { } + /// Visiting ``ThrownTypeSyntax`` specifically. + /// - Parameter node: the node we are visiting. + /// - Returns: how should we continue visiting. + open func visit(_ node: ThrownTypeSyntax) -> SyntaxVisitorContinueKind { + return .visitChildren + } + + /// The function called after visiting ``ThrownTypeSyntax`` and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: ThrownTypeSyntax) { + } + /// Visiting ``TryExprSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. @@ -4394,6 +4406,10 @@ open class SyntaxVisitor { return { self.visitImpl($0, ThrowStmtSyntax.self, self.visit, self.visitPost) } + case .thrownType: + return { + self.visitImpl($0, ThrownTypeSyntax.self, self.visit, self.visitPost) + } case .tryExpr: return { self.visitImpl($0, TryExprSyntax.self, self.visit, self.visitPost) @@ -5021,6 +5037,8 @@ open class SyntaxVisitor { visitImpl(node, ThenStmtSyntax.self, visit, visitPost) case .throwStmt: visitImpl(node, ThrowStmtSyntax.self, visit, visitPost) + case .thrownType: + visitImpl(node, ThrownTypeSyntax.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 db2864d3bf0..1095dccb002 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift @@ -312,17 +312,21 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, - _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, + thrownType: RawThrownTypeSyntax?, + _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in + kind: .accessorEffectSpecifiers, uninitializedCount: 7, 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] = unexpectedAfterThrowsSpecifier?.raw + layout[4] = unexpectedBetweenThrowsSpecifierAndThrownType?.raw + layout[5] = thrownType?.raw + layout[6] = unexpectedAfterThrownType?.raw } self.init(unchecked: raw) } @@ -343,9 +347,17 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var thrownType: RawThrownTypeSyntax? { + layoutView.children[5].map(RawThrownTypeSyntax.init(raw:)) + } + + public var unexpectedAfterThrownType: 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 da079023bdc..5524093184e 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift @@ -2002,17 +2002,21 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, - _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, + thrownType: RawThrownTypeSyntax?, + _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in + kind: .functionEffectSpecifiers, uninitializedCount: 7, 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] = unexpectedAfterThrowsSpecifier?.raw + layout[4] = unexpectedBetweenThrowsSpecifierAndThrownType?.raw + layout[5] = thrownType?.raw + layout[6] = unexpectedAfterThrownType?.raw } self.init(unchecked: raw) } @@ -2033,9 +2037,17 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var thrownType: RawThrownTypeSyntax? { + layoutView.children[5].map(RawThrownTypeSyntax.init(raw:)) + } + + public var unexpectedAfterThrownType: 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 38e4d2766ea..af78fdd9828 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift @@ -250,6 +250,88 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } } +@_spi(RawSyntax) +public struct RawThrownTypeSyntax: RawSyntaxNodeProtocol { + @_spi(RawSyntax) + public var layoutView: RawSyntaxLayoutView { + return raw.layoutView! + } + + public static func isKindOf(_ raw: RawSyntax) -> Bool { + return raw.kind == .thrownType + } + + public var raw: RawSyntax + + init(raw: RawSyntax) { + precondition(Self.isKindOf(raw)) + self.raw = raw + } + + private init(unchecked raw: RawSyntax) { + self.raw = raw + } + + public init?(_ other: some RawSyntaxNodeProtocol) { + guard Self.isKindOf(other.raw) else { + return nil + } + self.init(unchecked: other.raw) + } + + public init( + _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, + leftParen: RawTokenSyntax, + _ unexpectedBetweenLeftParenAndType: RawUnexpectedNodesSyntax? = nil, + type: RawTypeSyntax, + _ unexpectedBetweenTypeAndRightParen: RawUnexpectedNodesSyntax? = nil, + rightParen: RawTokenSyntax, + _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { + let raw = RawSyntax.makeLayout( + kind: .thrownType, uninitializedCount: 7, 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 + } + self.init(unchecked: raw) + } + + public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? { + layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var leftParen: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedBetweenLeftParenAndType: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var type: RawTypeSyntax { + layoutView.children[3].map(RawTypeSyntax.init(raw:))! + } + + public var unexpectedBetweenTypeAndRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) + } + + public var rightParen: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } +} + @_spi(RawSyntax) public struct RawTryExprSyntax: RawExprSyntaxNodeProtocol { @_spi(RawSyntax) @@ -1136,17 +1218,21 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, - _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, + thrownType: RawThrownTypeSyntax?, + _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in + kind: .typeEffectSpecifiers, uninitializedCount: 7, 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] = unexpectedAfterThrowsSpecifier?.raw + layout[4] = unexpectedBetweenThrowsSpecifierAndThrownType?.raw + layout[5] = thrownType?.raw + layout[6] = unexpectedAfterThrownType?.raw } self.init(unchecked: raw) } @@ -1167,9 +1253,17 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var thrownType: RawThrownTypeSyntax? { + layoutView.children[5].map(RawThrownTypeSyntax.init(raw:)) + } + + public var unexpectedAfterThrownType: 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 307b5d1eccb..8d9aaf694a2 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -253,12 +253,14 @@ 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 == 5) + assert(layout.count == 7) 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, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeSyntax?.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)) @@ -1251,12 +1253,14 @@ 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 == 5) + assert(layout.count == 7) 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, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeSyntax?.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)) @@ -2469,6 +2473,15 @@ 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 .thrownType: + assert(layout.count == 7) + assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 3, verify(layout[3], as: RawTypeSyntax.self)) + assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .tryExpr: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) @@ -2566,12 +2579,14 @@ 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 == 5) + assert(layout.count == 7) 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, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeSyntax?.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 f34952deaae..d50418b5712 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -525,6 +525,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// /// - `asyncSpecifier`: `async`? /// - `throwsSpecifier`: `throws`? +/// - `thrownType`: ``ThrownTypeSyntax``? /// /// ### Contained in /// @@ -550,7 +551,9 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier: TokenSyntax? = nil, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, + thrownType: ThrownTypeSyntax? = nil, + _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -561,14 +564,18 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, - unexpectedAfterThrowsSpecifier + unexpectedBetweenThrowsSpecifierAndThrownType, + thrownType, + unexpectedAfterThrownType ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, throwsSpecifier?.raw, - unexpectedAfterThrowsSpecifier?.raw + unexpectedBetweenThrowsSpecifierAndThrownType?.raw, + thrownType?.raw, + unexpectedAfterThrownType?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorEffectSpecifiers, @@ -628,7 +635,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -637,13 +644,33 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public var thrownType: ThrownTypeSyntax? { + get { + return Syntax(self).child(at: 5)?.cast(ThrownTypeSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(AccessorEffectSpecifiersSyntax.self) + } + } + + public var unexpectedAfterThrownType: 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.unexpectedAfterThrowsSpecifier + \Self.unexpectedBetweenThrowsSpecifierAndThrownType, + \Self.thrownType, + \Self.unexpectedAfterThrownType ]) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index f9b219835e6..aedcb637f16 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -3703,6 +3703,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// /// - `asyncSpecifier`: (`async` | `reasync`)? /// - `throwsSpecifier`: (`throws` | `rethrows`)? +/// - `thrownType`: ``ThrownTypeSyntax``? /// /// ### Contained in /// @@ -3728,7 +3729,9 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier: TokenSyntax? = nil, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, + thrownType: ThrownTypeSyntax? = nil, + _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3739,14 +3742,18 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, - unexpectedAfterThrowsSpecifier + unexpectedBetweenThrowsSpecifierAndThrownType, + thrownType, + unexpectedAfterThrownType ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, throwsSpecifier?.raw, - unexpectedAfterThrowsSpecifier?.raw + unexpectedBetweenThrowsSpecifierAndThrownType?.raw, + thrownType?.raw, + unexpectedAfterThrownType?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionEffectSpecifiers, @@ -3810,7 +3817,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -3819,13 +3826,33 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } + public var thrownType: ThrownTypeSyntax? { + get { + return Syntax(self).child(at: 5)?.cast(ThrownTypeSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(FunctionEffectSpecifiersSyntax.self) + } + } + + public var unexpectedAfterThrownType: 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.unexpectedAfterThrowsSpecifier + \Self.unexpectedBetweenThrowsSpecifierAndThrownType, + \Self.thrownType, + \Self.unexpectedAfterThrownType ]) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift index e183da7df18..ae97e96c928 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift @@ -468,6 +468,158 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } +// MARK: - ThrownTypeSyntax + +/// ### Children +/// +/// - `leftParen`: `(` +/// - `type`: ``TypeSyntax`` +/// - `rightParen`: `)` +/// +/// ### Contained in +/// +/// - ``AccessorEffectSpecifiersSyntax``.``AccessorEffectSpecifiersSyntax/thrownType`` +/// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/thrownType`` +/// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/thrownType`` +public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { + public let _syntaxNode: Syntax + + public init?(_ node: some SyntaxProtocol) { + guard node.raw.kind == .thrownType else { + return nil + } + self._syntaxNode = node._syntaxNode + } + + /// - 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. + /// - 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(), + _ unexpectedBetweenLeftParenAndType: UnexpectedNodesSyntax? = nil, + type: some TypeSyntaxProtocol, + _ unexpectedBetweenTypeAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + + ) { + // 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, + leftParen, + unexpectedBetweenLeftParenAndType, + type, + unexpectedBetweenTypeAndRightParen, + rightParen, + unexpectedAfterRightParen + ))) { (arena, _) in + let layout: [RawSyntax?] = [ + unexpectedBeforeLeftParen?.raw, + leftParen.raw, + unexpectedBetweenLeftParenAndType?.raw, + type.raw, + unexpectedBetweenTypeAndRightParen?.raw, + rightParen.raw, + unexpectedAfterRightParen?.raw + ] + let raw = RawSyntax.makeLayout( + kind: SyntaxKind.thrownType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) + return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) + } + } + + public var unexpectedBeforeLeftParen: 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(ThrownTypeSyntax.self) + } + } + + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `(`. + public var leftParen: 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(ThrownTypeSyntax.self) + } + } + + public var unexpectedBetweenLeftParenAndType: 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(ThrownTypeSyntax.self) + } + } + + public var type: TypeSyntax { + get { + return Syntax(self).child(at: 3)!.cast(TypeSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + } + } + + public var unexpectedBetweenTypeAndRightParen: 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(ThrownTypeSyntax.self) + } + } + + /// ### Tokens + /// + /// For syntax trees generated by the parser, this is guaranteed to be `)`. + public var rightParen: TokenSyntax { + get { + return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + } + } + + public var unexpectedAfterRightParen: 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(ThrownTypeSyntax.self) + } + } + + public static var structure: SyntaxNodeStructure { + return .layout([ + \Self.unexpectedBeforeLeftParen, + \Self.leftParen, + \Self.unexpectedBetweenLeftParenAndType, + \Self.type, + \Self.unexpectedBetweenTypeAndRightParen, + \Self.rightParen, + \Self.unexpectedAfterRightParen + ]) + } +} + // MARK: - TryExprSyntax /// An expression prefixed with `try`. @@ -2080,6 +2232,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// /// - `asyncSpecifier`: `async`? /// - `throwsSpecifier`: `throws`? +/// - `thrownType`: ``ThrownTypeSyntax``? /// /// ### Contained in /// @@ -2105,7 +2258,9 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS asyncSpecifier: TokenSyntax? = nil, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, + thrownType: ThrownTypeSyntax? = nil, + _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2116,14 +2271,18 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS asyncSpecifier, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, - unexpectedAfterThrowsSpecifier + unexpectedBetweenThrowsSpecifierAndThrownType, + thrownType, + unexpectedAfterThrownType ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, throwsSpecifier?.raw, - unexpectedAfterThrowsSpecifier?.raw + unexpectedBetweenThrowsSpecifierAndThrownType?.raw, + thrownType?.raw, + unexpectedAfterThrownType?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeEffectSpecifiers, @@ -2179,7 +2338,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - public var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -2188,13 +2347,33 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } + public var thrownType: ThrownTypeSyntax? { + get { + return Syntax(self).child(at: 5)?.cast(ThrownTypeSyntax.self) + } + set(value) { + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(TypeEffectSpecifiersSyntax.self) + } + } + + public var unexpectedAfterThrownType: 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.unexpectedAfterThrowsSpecifier + \Self.unexpectedBetweenThrowsSpecifierAndThrownType, + \Self.thrownType, + \Self.unexpectedAfterThrownType ]) } } From d6e4880188870e1b6d67c930692ab22309100116 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Sat, 16 Sep 2023 22:27:11 -0700 Subject: [PATCH 03/17] [Typed throws] Parse typed throws in effect specifiers --- Sources/SwiftParser/Specifiers.swift | 64 +++++++++++++++---- Sources/SwiftParser/Types.swift | 9 ++- .../ParseDiagnosticsGenerator.swift | 6 +- Tests/SwiftParserTest/DeclarationTests.swift | 14 ++++ Tests/SwiftParserTest/TypeTests.swift | 12 ++++ 5 files changed, 90 insertions(+), 15 deletions(-) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index d901a118957..b7614afcdc7 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -128,6 +128,13 @@ public enum EffectSpecifier: TokenSpecSet { case .throwsSpecifier(let underlyingKind): return underlyingKind.spec } } + + var isThrowsSpecifier: Bool { + switch self { + case .asyncSpecifier: return false + case .throwsSpecifier: return true + } + } } // MARK: - EffectSpecifiersTrait @@ -153,10 +160,12 @@ protocol RawMisplacedEffectSpecifiersTrait { var asyncSpecifier: RawTokenSyntax? { get } var throwsSpecifier: RawTokenSyntax? { get } + var thrownType: RawThrownTypeSyntax? { get } init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, + thrownType: RawThrownTypeSyntax?, arena: __shared SyntaxArena ) @@ -166,14 +175,17 @@ protocol RawMisplacedEffectSpecifiersTrait { protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait { var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get } var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { get } - var unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? { get } - + var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { get } + var thrownType: RawThrownTypeSyntax? { get } + var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { get } init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax?, asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax?, throwsSpecifier: RawTokenSyntax?, - _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax?, + _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax?, + thrownType: RawThrownTypeSyntax?, + _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) } @@ -182,6 +194,7 @@ extension RawEffectSpecifiersTrait { init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, + thrownType: RawThrownTypeSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -190,6 +203,8 @@ extension RawEffectSpecifiersTrait { nil, throwsSpecifier: throwsSpecifier, nil, + thrownType: thrownType, + nil, arena: arena ) } @@ -200,7 +215,9 @@ extension RawEffectSpecifiersTrait { asyncSpecifier: self.asyncSpecifier ?? misplacedAsyncKeyword, self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier: self.throwsSpecifier ?? misplacedThrowsKeyword, - self.unexpectedAfterThrowsSpecifier, + self.unexpectedBetweenThrowsSpecifierAndThrownType, + thrownType: thrownType, + self.unexpectedAfterThrownType, arena: arena ) } @@ -521,10 +538,12 @@ extension RawDeinitializerEffectSpecifiersSyntax: RawMisplacedEffectSpecifiersTr } var throwsSpecifier: RawTokenSyntax? { nil } + var thrownType: RawThrownTypeSyntax? { nil } init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, + thrownType: RawThrownTypeSyntax?, arena: __shared SwiftSyntax.SyntaxArena ) { // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens @@ -577,12 +596,28 @@ extension TokenConsumer { // MARK: - Parsing effect specifiers extension Parser { + private mutating func parseThrownType() -> RawThrownTypeSyntax { + let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen) + let type = self.parseType() + let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) + return RawThrownTypeSyntax( + unexpectedBeforeLeftParen, + leftParen: leftParen, + type: type, + unexpectedBeforeRightParen, + rightParen: rightParen, + arena: self.arena + ) + } + private mutating func parseEffectSpecifiers(_: S.Type) -> S? { var unexpectedBeforeAsync: [RawSyntax] = [] var asyncKeyword: RawTokenSyntax? = nil var unexpectedBeforeThrows: [RawSyntax] = [] var throwsKeyword: RawTokenSyntax? - var unexpectedAfterThrows: [RawSyntax] = [] + var thrownType: RawThrownTypeSyntax? + var unexpectedAfterThrownType: [RawSyntax] = [] + while let misspelledAsync = self.consume(ifAnyIn: S.MisspelledAsyncTokenKinds.self) { unexpectedBeforeAsync.append(RawSyntax(misspelledAsync)) if asyncKeyword == nil { @@ -619,24 +654,28 @@ extension Parser { throwsKeyword = throwsKw } - var unexpectedAfterThrowsLoopProgress = LoopProgressCondition() - while self.hasProgressed(&unexpectedAfterThrowsLoopProgress) { + if throwsKeyword != nil && self.at(.leftParen) { + thrownType = parseThrownType() + } + + var unexpectedAfterThrownTypeLoopProgress = LoopProgressCondition() + while self.hasProgressed(&unexpectedAfterThrownTypeLoopProgress) { if let (_, handle, _) = self.at(anyIn: S.MisspelledAsyncTokenKinds.self, or: S.CorrectAsyncTokenKinds.self) { let misspelledAsync = self.eat(handle) - unexpectedAfterThrows.append(RawSyntax(misspelledAsync)) + unexpectedAfterThrownType.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) - unexpectedAfterThrows.append(RawSyntax(misspelledThrows)) + unexpectedAfterThrownType.append(RawSyntax(misspelledThrows)) } else { break } } - if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && unexpectedAfterThrows.isEmpty { + if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && thrownType == nil && unexpectedAfterThrownType.isEmpty { return nil } @@ -645,7 +684,9 @@ extension Parser { asyncSpecifier: asyncKeyword, RawUnexpectedNodesSyntax(unexpectedBeforeThrows, arena: self.arena), throwsSpecifier: throwsKeyword, - RawUnexpectedNodesSyntax(unexpectedAfterThrows, arena: self.arena), + nil, + thrownType: thrownType, + RawUnexpectedNodesSyntax(unexpectedAfterThrownType, arena: self.arena), arena: self.arena ) } @@ -749,6 +790,7 @@ extension Parser { effectSpecifiers = S( asyncSpecifier: synthesizedAsync, throwsSpecifier: synthesizedThrows, + thrownType: nil, arena: self.arena ) } diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift index 7a60e00ad22..44c284ac32a 100644 --- a/Sources/SwiftParser/Types.swift +++ b/Sources/SwiftParser/Types.swift @@ -800,11 +800,18 @@ extension Parser.Lookahead { return true } - if self.at(anyIn: EffectSpecifier.self) != nil { + if let effect = self.at(anyIn: EffectSpecifier.self) { if self.peek().rawTokenKind == .arrow { return true } + if effect.spec.isThrowsSpecifier && self.peek().rawTokenKind == .leftParen { + var backtrack = self.lookahead() + backtrack.consumeAnyToken() + backtrack.skipSingle() + return backtrack.atFunctionTypeArrow() + } + if peek(isAtAnyIn: EffectSpecifier.self) != nil { var backtrack = self.lookahead() backtrack.consumeAnyToken() diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index bdcaf26aa03..4094bed53c0 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -258,7 +258,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { (node.throwsSpecifier, { ThrowsEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledThrows), ] - let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedAfterThrowsSpecifier] + let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier,node.unexpectedBetweenThrowsSpecifierAndThrownType, node.unexpectedAfterThrownType] // Diagnostics that are emitted later silence previous diagnostics, so check // for the most contextual (and thus helpful) diagnostics last. @@ -279,9 +279,9 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { } } - if let throwsSpecifier = node.throwsSpecifier { + if let throwsSpecifier = node.throwsSpecifier, node.thrownType == nil { exchangeTokens( - unexpected: node.unexpectedAfterThrowsSpecifier, + unexpected: node.unexpectedAfterThrownType, unexpectedTokenCondition: { AsyncEffectSpecifier(token: $0) != nil }, correctTokens: [node.asyncSpecifier], message: { AsyncMustPrecedeThrows(asyncKeywords: $0, throwsKeyword: throwsSpecifier) }, diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 11995874804..76761d181fd 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -891,6 +891,20 @@ final class DeclarationTests: ParserTestCase { ) } + func testTypedThrows() { + assertParse( + "func test() throws(any Error) -> Int { }" + ) + + assertParse( + """ + struct X { + init() throws(any Error) { } + } + """ + ) + } + func testExtraneousRightBraceRecovery() { assertParse( """ diff --git a/Tests/SwiftParserTest/TypeTests.swift b/Tests/SwiftParserTest/TypeTests.swift index 090c541c965..35a9c22a43c 100644 --- a/Tests/SwiftParserTest/TypeTests.swift +++ b/Tests/SwiftParserTest/TypeTests.swift @@ -304,4 +304,16 @@ final class TypeTests: ParserTestCase { ] ) } + + func testTypedThrows() { + assertParse( + """ + { () throws(PosixError) -> Void in } + """ + ) + + assertParse("typealias T = () throws(PosixError) -> Void") + + assertParse("[() throws(PosixError) -> Void]()") + } } From 7557530f740ba00bfea98e27d74a9d8826f12c0c Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 22 Sep 2023 11:51:16 -0700 Subject: [PATCH 04/17] Introduce an experimental feature for typed throws --- Sources/SwiftParser/Specifiers.swift | 2 +- .../generated/ExperimentalFeatures.swift | 3 +++ Tests/SwiftParserTest/DeclarationTests.swift | 6 ++++-- Tests/SwiftParserTest/TypeTests.swift | 15 +++++++++++---- 4 files changed, 19 insertions(+), 7 deletions(-) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index b7614afcdc7..805937e774b 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -654,7 +654,7 @@ extension Parser { throwsKeyword = throwsKw } - if throwsKeyword != nil && self.at(.leftParen) { + if throwsKeyword != nil && self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { thrownType = parseThrownType() } diff --git a/Sources/SwiftParser/generated/ExperimentalFeatures.swift b/Sources/SwiftParser/generated/ExperimentalFeatures.swift index b8fe727b8de..651541d152a 100644 --- a/Sources/SwiftParser/generated/ExperimentalFeatures.swift +++ b/Sources/SwiftParser/generated/ExperimentalFeatures.swift @@ -29,4 +29,7 @@ extension Parser.ExperimentalFeatures { /// Whether to enable the parsing of 'then' statements. public static let thenStatements = Self(rawValue: 1 << 1) + + /// Whether to enable the parsing of typed throws. + public static let typedThrows = Self(rawValue: 1 << 2) } diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 76761d181fd..23fa45138fc 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -893,7 +893,8 @@ final class DeclarationTests: ParserTestCase { func testTypedThrows() { assertParse( - "func test() throws(any Error) -> Int { }" + "func test() throws(any Error) -> Int { }", + experimentalFeatures: [.typedThrows] ) assertParse( @@ -901,7 +902,8 @@ final class DeclarationTests: ParserTestCase { struct X { init() throws(any Error) { } } - """ + """, + experimentalFeatures: [.typedThrows] ) } diff --git a/Tests/SwiftParserTest/TypeTests.swift b/Tests/SwiftParserTest/TypeTests.swift index 35a9c22a43c..563e4713011 100644 --- a/Tests/SwiftParserTest/TypeTests.swift +++ b/Tests/SwiftParserTest/TypeTests.swift @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -@_spi(RawSyntax) import SwiftParser +@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftParser @_spi(RawSyntax) import SwiftSyntax import XCTest @@ -309,11 +309,18 @@ final class TypeTests: ParserTestCase { assertParse( """ { () throws(PosixError) -> Void in } - """ + """, + experimentalFeatures: [.typedThrows] ) - assertParse("typealias T = () throws(PosixError) -> Void") + assertParse( + "typealias T = () throws(PosixError) -> Void", + experimentalFeatures: [.typedThrows] + ) - assertParse("[() throws(PosixError) -> Void]()") + assertParse( + "[() throws(PosixError) -> Void]()", + experimentalFeatures: [.typedThrows] + ) } } From 93f2a15826b0ce6b818411debf1e5ece585f79bc Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Thu, 28 Sep 2023 16:03:40 -0700 Subject: [PATCH 05/17] Add documentation and improve names for typed throws syntax nodes --- .../Sources/SyntaxSupport/CommonNodes.swift | 23 ++++++++++++------- .../SyntaxSupport/ExperimentalFeatures.swift | 3 +++ .../SyntaxSupport/SyntaxNodeKind.swift | 2 +- .../Sources/SyntaxSupport/Traits.swift | 3 ++- Release Notes/510.md | 3 +++ 5 files changed, 24 insertions(+), 10 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index 8876e6e67d8..55f56659ecd 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -80,22 +80,26 @@ public let COMMON_NODES: [Node] = [ ), Node( - kind: .thrownType, + kind: .thrownTypeClause, base: .syntax, - nameForDiagnostics: "thrown type", + nameForDiagnostics: "thrown type clause", + documentation: "The specific error type that a function can throw.", children: [ Child( name: "leftParen", - kind: .token(choices: [.token(.leftParen)]) + kind: .token(choices: [.token(.leftParen)]), + documentation: "The '(' to open the thrown type clause." ), Child( name: "type", kind: .node(kind: .type), - nameForDiagnostics: "type" + nameForDiagnostics: "thrown type", + documentation: "The thrown error type." ), Child( name: "rightParen", - kind: .token(choices: [.token(.rightParen)]) + kind: .token(choices: [.token(.rightParen)]), + documentation: "The ')' to closure the thrown type clause." ), ] ), @@ -122,7 +126,8 @@ public let COMMON_NODES: [Node] = [ ), Child( name: "thrownType", - kind: .node(kind: .thrownType), + kind: .node(kind: .thrownTypeClause), + documentation: "The specific error type thrown by this accessor.", isOptional: true ), ] @@ -150,7 +155,8 @@ public let COMMON_NODES: [Node] = [ ), Child( name: "thrownType", - kind: .node(kind: .thrownType), + kind: .node(kind: .thrownTypeClause), + documentation: "The specific error type thrown by this function.", isOptional: true ), ] @@ -357,7 +363,8 @@ public let COMMON_NODES: [Node] = [ ), Child( name: "thrownType", - kind: .node(kind: .thrownType), + kind: .node(kind: .thrownTypeClause), + documentation: "The specific error type thrown by this function type.", isOptional: true ), ] diff --git a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift index 2ea4c215ef0..edb42bfef0a 100644 --- a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift +++ b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift @@ -15,6 +15,7 @@ import SwiftSyntax public enum ExperimentalFeature: String, CaseIterable { case referenceBindings case thenStatements + case typedThrows /// The name of the feature, which is used in the doc comment. public var featureName: String { @@ -23,6 +24,8 @@ public enum ExperimentalFeature: String, CaseIterable { return "reference bindings" case .thenStatements: return "'then' statements" + case .typedThrows: + return "typed throws" } } diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift index 731f84fa56e..ca743dfd753 100644 --- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift +++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift @@ -268,7 +268,7 @@ public enum SyntaxNodeKind: String, CaseIterable { case switchExpr case ternaryExpr case thenStmt - case thrownType + case thrownTypeClause case throwStmt case tryExpr case tupleExpr diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index c8062f07149..38359bf14b3 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -59,7 +59,8 @@ public let TRAITS: [Trait] = [ Child(name: "unexpectedBetweenThrowsSpecifierAndThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), Child( name: "thrownType", - kind: .node(kind: .thrownType), + kind: .node(kind: .thrownTypeClause), + documentation: "The specific thrown error type.", isOptional: true ), Child(name: "unexpectedAfterThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), diff --git a/Release Notes/510.md b/Release Notes/510.md index 286fc5dde69..95f1c1f780c 100644 --- a/Release Notes/510.md +++ b/Release Notes/510.md @@ -50,6 +50,9 @@ ## API-Incompatible Changes +- Effect specifiers: + - Description: The `unexpectedAfterThrowsSpecifier` node of the various effect specifiers has been removed. + - Pull request: https://github.com/apple/swift-syntax/pull/2219 ## Template From fd475cba57cff60b17aab70ffea6521ae5547204 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Thu, 28 Sep 2023 16:17:58 -0700 Subject: [PATCH 06/17] Add support for experimental child nodes --- .../Sources/SyntaxSupport/Child.swift | 19 +++++++++++++++++++ .../swiftsyntax/SyntaxNodesFile.swift | 2 +- .../swiftsyntax/SyntaxTraitsFile.swift | 2 +- 3 files changed, 21 insertions(+), 2 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/Child.swift b/CodeGeneration/Sources/SyntaxSupport/Child.swift index fd4bf988bce..6cc585241a9 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Child.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Child.swift @@ -82,6 +82,10 @@ public class Child { /// Whether this child is optional and can be `nil`. public let isOptional: Bool + /// The experimental feature the child represents, or `nil` if this isn't + /// for an experimental feature. + public let experimentalFeature: ExperimentalFeature? + /// A name of this child that can be shown in diagnostics. /// /// This is used to e.g. describe the child if all of its tokens are missing in the source file. @@ -110,6 +114,10 @@ public class Child { /// The first line of the child's documentation public let documentationAbstract: String + /// If `true`, this is for an experimental language feature, and any public + /// API generated should be SPI. + public var isExperimental: Bool { experimentalFeature != nil } + public var syntaxNodeKind: SyntaxNodeKind { switch kind { case .node(kind: let kind): @@ -218,6 +226,15 @@ public class Child { } } + /// The attributes that should be printed on any API for the this child. + /// + /// This is typically used to mark APIs as SPI when the keyword is part of + /// an experimental language feature. + public var apiAttributes: AttributeListSyntax { + guard isExperimental else { return "" } + return AttributeListSyntax("@_spi(ExperimentalLanguageFeatures)").with(\.trailingTrivia, .newline) + } + /// If a classification is passed, it specifies the color identifiers in /// that subtree should inherit for syntax coloring. Must be a member of /// ``SyntaxClassification``. @@ -227,6 +244,7 @@ public class Child { name: String, deprecatedName: String? = nil, kind: ChildKind, + experimentalFeature: ExperimentalFeature? = nil, nameForDiagnostics: String? = nil, documentation: String? = nil, isOptional: Bool = false @@ -236,6 +254,7 @@ public class Child { self.name = name self.deprecatedName = deprecatedName self.kind = kind + self.experimentalFeature = experimentalFeature self.nameForDiagnostics = nameForDiagnostics self.documentationSummary = SwiftSyntax.Trivia.docCommentTrivia(from: documentation) self.documentationAbstract = String(documentation?.split(whereSeparator: \.isNewline).first ?? "") diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift index 042e7d396ae..f766af47ec3 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift @@ -138,7 +138,7 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { try! VariableDeclSyntax( """ \(child.documentation) - public var \(child.varOrCaseName.backtickedIfNeeded): \(type) + \(child.apiAttributes)public var \(child.varOrCaseName.backtickedIfNeeded): \(type) """ ) { AccessorDeclSyntax(accessorSpecifier: .keyword(.get)) { diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift index 3ffe8b62623..1081a33ec7f 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift @@ -31,7 +31,7 @@ let syntaxTraitsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { DeclSyntax( """ \(child.documentation) - var \(child.varOrCaseName): \(child.syntaxNodeKind.syntaxType)\(questionMark) { get set } + \(child.apiAttributes)var \(child.varOrCaseName): \(child.syntaxNodeKind.syntaxType)\(questionMark) { get set } """ ) } From 9e7cb5eca08e7e82608b08f42fb3e777c854be91 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Thu, 28 Sep 2023 16:18:55 -0700 Subject: [PATCH 07/17] Mark thrown type clauses as experimental --- CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift | 3 +++ CodeGeneration/Sources/SyntaxSupport/Traits.swift | 1 + 2 files changed, 4 insertions(+) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index 55f56659ecd..74a88705cc8 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -127,6 +127,7 @@ public let COMMON_NODES: [Node] = [ Child( name: "thrownType", kind: .node(kind: .thrownTypeClause), + experimentalFeature: .typedThrows, documentation: "The specific error type thrown by this accessor.", isOptional: true ), @@ -156,6 +157,7 @@ public let COMMON_NODES: [Node] = [ Child( name: "thrownType", kind: .node(kind: .thrownTypeClause), + experimentalFeature: .typedThrows, documentation: "The specific error type thrown by this function.", isOptional: true ), @@ -364,6 +366,7 @@ public let COMMON_NODES: [Node] = [ Child( name: "thrownType", kind: .node(kind: .thrownTypeClause), + experimentalFeature: .typedThrows, documentation: "The specific error type thrown by this function type.", isOptional: true ), diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index 38359bf14b3..190aa571c5a 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -60,6 +60,7 @@ public let TRAITS: [Trait] = [ Child( name: "thrownType", kind: .node(kind: .thrownTypeClause), + experimentalFeature: .typedThrows, documentation: "The specific thrown error type.", isOptional: true ), From c59598010fc027301b56d0f27ad71d672659193f Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Thu, 28 Sep 2023 16:20:57 -0700 Subject: [PATCH 08/17] Regenerate --- .../generated/ExperimentalFeatures.swift | 2 +- .../generated/ChildNameForDiagnostics.swift | 4 +- .../SyntaxKindNameForDiagnostics.swift | 4 +- .../generated/SwiftSyntax.md | 2 +- .../generated/ChildNameForKeyPath.swift | 14 +++--- .../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 | 4 +- .../generated/SyntaxTransform.swift | 10 ++--- .../SwiftSyntax/generated/SyntaxVisitor.swift | 16 +++---- .../generated/raw/RawSyntaxNodesAB.swift | 6 +-- .../generated/raw/RawSyntaxNodesEF.swift | 6 +-- .../generated/raw/RawSyntaxNodesTUVWXYZ.swift | 12 +++--- .../generated/raw/RawSyntaxValidation.swift | 8 ++-- .../generated/syntaxNodes/SyntaxNodesAB.swift | 11 +++-- .../generated/syntaxNodes/SyntaxNodesEF.swift | 11 +++-- .../syntaxNodes/SyntaxNodesTUVWXYZ.swift | 43 ++++++++++++------- 20 files changed, 102 insertions(+), 81 deletions(-) diff --git a/Sources/SwiftParser/generated/ExperimentalFeatures.swift b/Sources/SwiftParser/generated/ExperimentalFeatures.swift index 651541d152a..1552a339de0 100644 --- a/Sources/SwiftParser/generated/ExperimentalFeatures.swift +++ b/Sources/SwiftParser/generated/ExperimentalFeatures.swift @@ -29,7 +29,7 @@ extension Parser.ExperimentalFeatures { /// Whether to enable the parsing of 'then' statements. public static let thenStatements = Self(rawValue: 1 << 1) - + /// Whether to enable the parsing of typed throws. public static let typedThrows = Self(rawValue: 1 << 2) } diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift index fde1020ab03..32daf689165 100644 --- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift @@ -332,8 +332,8 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? { return "first choice" case \TernaryExprSyntax.elseExpression: return "second choice" - case \ThrownTypeSyntax.type: - return "type" + case \ThrownTypeClauseSyntax.type: + return "thrown type" case \TuplePatternElementSyntax.label: return "label" case \TupleTypeElementSyntax.firstName: diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift index a2f476a6bba..dbbbad075f6 100644 --- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift +++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift @@ -361,8 +361,8 @@ extension SyntaxKind { return "'then' statement" case .throwStmt: return "'throw' statement" - case .thrownType: - return "thrown type" + case .thrownTypeClause: + return "thrown type 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 586d2074b4b..02a10fe376c 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 3422f1ce69c..1d472b71121 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -3091,19 +3091,19 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "expression" case \ThrowStmtSyntax.unexpectedAfterExpression: return "unexpectedAfterExpression" - case \ThrownTypeSyntax.unexpectedBeforeLeftParen: + case \ThrownTypeClauseSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" - case \ThrownTypeSyntax.leftParen: + case \ThrownTypeClauseSyntax.leftParen: return "leftParen" - case \ThrownTypeSyntax.unexpectedBetweenLeftParenAndType: + case \ThrownTypeClauseSyntax.unexpectedBetweenLeftParenAndType: return "unexpectedBetweenLeftParenAndType" - case \ThrownTypeSyntax.type: + case \ThrownTypeClauseSyntax.type: return "type" - case \ThrownTypeSyntax.unexpectedBetweenTypeAndRightParen: + case \ThrownTypeClauseSyntax.unexpectedBetweenTypeAndRightParen: return "unexpectedBetweenTypeAndRightParen" - case \ThrownTypeSyntax.rightParen: + case \ThrownTypeClauseSyntax.rightParen: return "rightParen" - case \ThrownTypeSyntax.unexpectedAfterRightParen: + case \ThrownTypeClauseSyntax.unexpectedAfterRightParen: return "unexpectedAfterRightParen" case \TryExprSyntax.unexpectedBeforeTryKeyword: return "unexpectedBeforeTryKeyword" diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift index fa6ca054546..24abe920deb 100644 --- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift @@ -2022,11 +2022,11 @@ open class SyntaxAnyVisitor: SyntaxVisitor { visitAnyPost(node._syntaxNode) } - override open func visit(_ node: ThrownTypeSyntax) -> SyntaxVisitorContinueKind { + override open func visit(_ node: ThrownTypeClauseSyntax) -> SyntaxVisitorContinueKind { return visitAny(node._syntaxNode) } - override open func visitPost(_ node: ThrownTypeSyntax) { + override open func visitPost(_ node: ThrownTypeClauseSyntax) { visitAnyPost(node._syntaxNode) } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index fc6738f3808..ecc5db7e07a 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -1769,7 +1769,7 @@ extension Syntax { .node(TernaryExprSyntax.self), .node(ThenStmtSyntax.self), .node(ThrowStmtSyntax.self), - .node(ThrownTypeSyntax.self), + .node(ThrownTypeClauseSyntax.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 8d28f6ec36b..eef23507358 100644 --- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift +++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift @@ -263,7 +263,7 @@ public enum SyntaxEnum { #endif case thenStmt(ThenStmtSyntax) case throwStmt(ThrowStmtSyntax) - case thrownType(ThrownTypeSyntax) + case thrownTypeClause(ThrownTypeClauseSyntax) case tryExpr(TryExprSyntax) case tupleExpr(TupleExprSyntax) case tuplePatternElementList(TuplePatternElementListSyntax) @@ -793,8 +793,8 @@ public extension Syntax { return .thenStmt(ThenStmtSyntax(self)!) case .throwStmt: return .throwStmt(ThrowStmtSyntax(self)!) - case .thrownType: - return .thrownType(ThrownTypeSyntax(self)!) + case .thrownTypeClause: + return .thrownTypeClause(ThrownTypeClauseSyntax(self)!) case .tryExpr: return .tryExpr(TryExprSyntax(self)!) case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift index c5d4e0944d5..f36edf12aef 100644 --- a/Sources/SwiftSyntax/generated/SyntaxKind.swift +++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift @@ -263,7 +263,7 @@ public enum SyntaxKind: CaseIterable { #endif case thenStmt case throwStmt - case thrownType + case thrownTypeClause case tryExpr case tupleExpr case tuplePatternElementList @@ -914,8 +914,8 @@ public enum SyntaxKind: CaseIterable { return ThenStmtSyntax.self case .throwStmt: return ThrowStmtSyntax.self - case .thrownType: - return ThrownTypeSyntax.self + case .thrownTypeClause: + return ThrownTypeClauseSyntax.self case .tryExpr: return TryExprSyntax.self case .tupleExpr: diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index 5e825731002..2892669d50e 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1798,10 +1798,10 @@ open class SyntaxRewriter { return StmtSyntax(visitChildren(node)) } - /// Visit a ``ThrownTypeSyntax``. + /// Visit a ``ThrownTypeClauseSyntax``. /// - Parameter node: the node that is being visited /// - Returns: the rewritten node - open func visit(_ node: ThrownTypeSyntax) -> ThrownTypeSyntax { + open func visit(_ node: ThrownTypeClauseSyntax) -> ThrownTypeClauseSyntax { return visitChildren(node) } @@ -3086,9 +3086,9 @@ open class SyntaxRewriter { return { self.visitImpl($0, ThrowStmtSyntax.self, self.visit) } - case .thrownType: + case .thrownTypeClause: return { - self.visitImpl($0, ThrownTypeSyntax.self, self.visit) + self.visitImpl($0, ThrownTypeClauseSyntax.self, self.visit) } case .tryExpr: return { @@ -3714,8 +3714,8 @@ open class SyntaxRewriter { return visitImpl(node, ThenStmtSyntax.self, visit) case .throwStmt: return visitImpl(node, ThrowStmtSyntax.self, visit) - case .thrownType: - return visitImpl(node, ThrownTypeSyntax.self, visit) + case .thrownTypeClause: + return visitImpl(node, ThrownTypeClauseSyntax.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 b69130f0961..c98e81d0857 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -157,7 +157,9 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var thrownType: ThrownTypeSyntax? { + /// The specific thrown error type. + @_spi(ExperimentalLanguageFeatures) + var thrownType: ThrownTypeClauseSyntax? { get set } diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index cd774a8d363..c2594badd85 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -1240,10 +1240,10 @@ public protocol SyntaxTransformVisitor { /// - Returns: the sum of whatever the child visitors return. func visit(_ node: ThrowStmtSyntax) -> ResultType - /// Visiting ``ThrownTypeSyntax`` specifically. + /// Visiting ``ThrownTypeClauseSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: the sum of whatever the child visitors return. - func visit(_ node: ThrownTypeSyntax) -> ResultType + func visit(_ node: ThrownTypeClauseSyntax) -> ResultType /// Visiting ``TryExprSyntax`` specifically. /// - Parameter node: the node we are visiting. @@ -3124,10 +3124,10 @@ extension SyntaxTransformVisitor { visitAny(Syntax(node)) } - /// Visiting ``ThrownTypeSyntax`` specifically. + /// Visiting ``ThrownTypeClauseSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: nil by default. - public func visit(_ node: ThrownTypeSyntax) -> ResultType { + public func visit(_ node: ThrownTypeClauseSyntax) -> ResultType { visitAny(Syntax(node)) } @@ -3842,7 +3842,7 @@ extension SyntaxTransformVisitor { return visit(derived) case .throwStmt(let derived): return visit(derived) - case .thrownType(let derived): + case .thrownTypeClause(let derived): return visit(derived) case .tryExpr(let derived): return visit(derived) diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift index a6063a2552d..1a4c027ee46 100644 --- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift +++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift @@ -2980,16 +2980,16 @@ open class SyntaxVisitor { open func visitPost(_ node: ThrowStmtSyntax) { } - /// Visiting ``ThrownTypeSyntax`` specifically. + /// Visiting ``ThrownTypeClauseSyntax`` specifically. /// - Parameter node: the node we are visiting. /// - Returns: how should we continue visiting. - open func visit(_ node: ThrownTypeSyntax) -> SyntaxVisitorContinueKind { + open func visit(_ node: ThrownTypeClauseSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } - /// The function called after visiting ``ThrownTypeSyntax`` and its descendants. + /// The function called after visiting ``ThrownTypeClauseSyntax`` and its descendants. /// - node: the node we just finished visiting. - open func visitPost(_ node: ThrownTypeSyntax) { + open func visitPost(_ node: ThrownTypeClauseSyntax) { } /// Visiting ``TryExprSyntax`` specifically. @@ -4406,9 +4406,9 @@ open class SyntaxVisitor { return { self.visitImpl($0, ThrowStmtSyntax.self, self.visit, self.visitPost) } - case .thrownType: + case .thrownTypeClause: return { - self.visitImpl($0, ThrownTypeSyntax.self, self.visit, self.visitPost) + self.visitImpl($0, ThrownTypeClauseSyntax.self, self.visit, self.visitPost) } case .tryExpr: return { @@ -5037,8 +5037,8 @@ open class SyntaxVisitor { visitImpl(node, ThenStmtSyntax.self, visit, visitPost) case .throwStmt: visitImpl(node, ThrowStmtSyntax.self, visit, visitPost) - case .thrownType: - visitImpl(node, ThrownTypeSyntax.self, visit, visitPost) + case .thrownTypeClause: + visitImpl(node, ThrownTypeClauseSyntax.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 1095dccb002..b46c32f8c7e 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift @@ -313,7 +313,7 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { @@ -351,8 +351,8 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var thrownType: RawThrownTypeSyntax? { - layoutView.children[5].map(RawThrownTypeSyntax.init(raw:)) + public var thrownType: RawThrownTypeClauseSyntax? { + layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) } public var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift index 5524093184e..92b81a2a656 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift @@ -2003,7 +2003,7 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { @@ -2041,8 +2041,8 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var thrownType: RawThrownTypeSyntax? { - layoutView.children[5].map(RawThrownTypeSyntax.init(raw:)) + public var thrownType: RawThrownTypeClauseSyntax? { + layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) } public var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift index af78fdd9828..1a0cd8311d6 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 RawThrownTypeSyntax: RawSyntaxNodeProtocol { +public struct RawThrownTypeClauseSyntax: RawSyntaxNodeProtocol { @_spi(RawSyntax) public var layoutView: RawSyntaxLayoutView { return raw.layoutView! } public static func isKindOf(_ raw: RawSyntax) -> Bool { - return raw.kind == .thrownType + return raw.kind == .thrownTypeClause } public var raw: RawSyntax @@ -290,7 +290,7 @@ public struct RawThrownTypeSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .thrownType, uninitializedCount: 7, arena: arena) { layout in + kind: .thrownTypeClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -1219,7 +1219,7 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { @@ -1257,8 +1257,8 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var thrownType: RawThrownTypeSyntax? { - layoutView.children[5].map(RawThrownTypeSyntax.init(raw:)) + public var thrownType: RawThrownTypeClauseSyntax? { + layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) } public var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 8d9aaf694a2..5849a53b3f1 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -259,7 +259,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("throws")])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeSyntax?.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) @@ -1259,7 +1259,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { 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, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeSyntax?.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) @@ -2473,7 +2473,7 @@ 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 .thrownType: + case .thrownTypeClause: assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)])) @@ -2585,7 +2585,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.keyword("throws")])) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) - assertNoError(kind, 5, verify(layout[5], as: RawThrownTypeSyntax?.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) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index d50418b5712..6044a5a4974 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -525,7 +525,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// /// - `asyncSpecifier`: `async`? /// - `throwsSpecifier`: `throws`? -/// - `thrownType`: ``ThrownTypeSyntax``? +/// - `thrownType`: ``ThrownTypeClauseSyntax``? /// /// ### Contained in /// @@ -544,6 +544,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// - 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. + /// - thrownType: The specific error type thrown by this accessor. /// - 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, @@ -552,7 +553,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, - thrownType: ThrownTypeSyntax? = nil, + thrownType: ThrownTypeClauseSyntax? = nil, _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -644,9 +645,11 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var thrownType: ThrownTypeSyntax? { + /// The specific error type thrown by this accessor. + @_spi(ExperimentalLanguageFeatures) + public var thrownType: ThrownTypeClauseSyntax? { get { - return Syntax(self).child(at: 5)?.cast(ThrownTypeSyntax.self) + 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) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index aedcb637f16..6b2a11ba55b 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -3703,7 +3703,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// /// - `asyncSpecifier`: (`async` | `reasync`)? /// - `throwsSpecifier`: (`throws` | `rethrows`)? -/// - `thrownType`: ``ThrownTypeSyntax``? +/// - `thrownType`: ``ThrownTypeClauseSyntax``? /// /// ### Contained in /// @@ -3722,6 +3722,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// - 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. + /// - thrownType: The specific error type thrown by this function. /// - 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, @@ -3730,7 +3731,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, - thrownType: ThrownTypeSyntax? = nil, + thrownType: ThrownTypeClauseSyntax? = nil, _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -3826,9 +3827,11 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var thrownType: ThrownTypeSyntax? { + /// The specific error type thrown by this function. + @_spi(ExperimentalLanguageFeatures) + public var thrownType: ThrownTypeClauseSyntax? { get { - return Syntax(self).child(at: 5)?.cast(ThrownTypeSyntax.self) + 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) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift index ae97e96c928..bfbc009ade9 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift @@ -468,8 +468,10 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt } } -// MARK: - ThrownTypeSyntax +// MARK: - ThrownTypeClauseSyntax +/// The specific error type that a function can throw. +/// /// ### Children /// /// - `leftParen`: `(` @@ -481,11 +483,11 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// - ``AccessorEffectSpecifiersSyntax``.``AccessorEffectSpecifiersSyntax/thrownType`` /// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/thrownType`` /// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/thrownType`` -public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { +public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { public let _syntaxNode: Syntax public init?(_ node: some SyntaxProtocol) { - guard node.raw.kind == .thrownType else { + guard node.raw.kind == .thrownTypeClause else { return nil } self._syntaxNode = node._syntaxNode @@ -493,6 +495,9 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP /// - 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. + /// - type: The thrown error type. + /// - rightParen: The ')' to closure the thrown type clause. /// - 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, @@ -527,7 +532,7 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.thrownType, + kind: SyntaxKind.thrownTypeClause, from: layout, arena: arena, leadingTrivia: leadingTrivia, @@ -543,10 +548,12 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } + /// The '(' to open the thrown type clause. + /// /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be `(`. @@ -555,7 +562,7 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP return Syntax(self).child(at: 1)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } @@ -564,16 +571,17 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } + /// The thrown error type. public var type: TypeSyntax { get { return Syntax(self).child(at: 3)!.cast(TypeSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } @@ -582,10 +590,12 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } + /// The ')' to closure the thrown type clause. + /// /// ### Tokens /// /// For syntax trees generated by the parser, this is guaranteed to be `)`. @@ -594,7 +604,7 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP return Syntax(self).child(at: 5)!.cast(TokenSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } @@ -603,7 +613,7 @@ public struct ThrownTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } set(value) { - self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeSyntax.self) + self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ThrownTypeClauseSyntax.self) } } @@ -2232,7 +2242,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// /// - `asyncSpecifier`: `async`? /// - `throwsSpecifier`: `throws`? -/// - `thrownType`: ``ThrownTypeSyntax``? +/// - `thrownType`: ``ThrownTypeClauseSyntax``? /// /// ### Contained in /// @@ -2251,6 +2261,7 @@ 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. + /// - thrownType: The specific error type thrown by this function type. /// - 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, @@ -2259,7 +2270,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, - thrownType: ThrownTypeSyntax? = nil, + thrownType: ThrownTypeClauseSyntax? = nil, _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil @@ -2347,9 +2358,11 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - public var thrownType: ThrownTypeSyntax? { + /// The specific error type thrown by this function type. + @_spi(ExperimentalLanguageFeatures) + public var thrownType: ThrownTypeClauseSyntax? { get { - return Syntax(self).child(at: 5)?.cast(ThrownTypeSyntax.self) + 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) From 7af0bebb814d21cb96cff089258606e1807e8bd2 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Thu, 28 Sep 2023 16:22:56 -0700 Subject: [PATCH 09/17] Update for new names --- Sources/SwiftParser/Specifiers.swift | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index 805937e774b..10bf0741151 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -160,12 +160,12 @@ protocol RawMisplacedEffectSpecifiersTrait { var asyncSpecifier: RawTokenSyntax? { get } var throwsSpecifier: RawTokenSyntax? { get } - var thrownType: RawThrownTypeSyntax? { get } + var thrownType: RawThrownTypeClauseSyntax? { get } init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, arena: __shared SyntaxArena ) @@ -176,7 +176,7 @@ protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait { var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get } var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { get } var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { get } - var thrownType: RawThrownTypeSyntax? { get } + var thrownType: RawThrownTypeClauseSyntax? { get } var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { get } init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax?, @@ -184,7 +184,7 @@ protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait { _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax?, throwsSpecifier: RawTokenSyntax?, _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax?, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) @@ -194,7 +194,7 @@ extension RawEffectSpecifiersTrait { init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -538,12 +538,12 @@ extension RawDeinitializerEffectSpecifiersSyntax: RawMisplacedEffectSpecifiersTr } var throwsSpecifier: RawTokenSyntax? { nil } - var thrownType: RawThrownTypeSyntax? { nil } + var thrownType: RawThrownTypeClauseSyntax? { nil } init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, - thrownType: RawThrownTypeSyntax?, + thrownType: RawThrownTypeClauseSyntax?, arena: __shared SwiftSyntax.SyntaxArena ) { // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens @@ -596,11 +596,11 @@ extension TokenConsumer { // MARK: - Parsing effect specifiers extension Parser { - private mutating func parseThrownType() -> RawThrownTypeSyntax { + private mutating func parseThrownTypeClause() -> RawThrownTypeClauseSyntax { let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen) let type = self.parseType() let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen) - return RawThrownTypeSyntax( + return RawThrownTypeClauseSyntax( unexpectedBeforeLeftParen, leftParen: leftParen, type: type, @@ -615,7 +615,7 @@ extension Parser { var asyncKeyword: RawTokenSyntax? = nil var unexpectedBeforeThrows: [RawSyntax] = [] var throwsKeyword: RawTokenSyntax? - var thrownType: RawThrownTypeSyntax? + var thrownType: RawThrownTypeClauseSyntax? var unexpectedAfterThrownType: [RawSyntax] = [] while let misspelledAsync = self.consume(ifAnyIn: S.MisspelledAsyncTokenKinds.self) { @@ -655,7 +655,7 @@ extension Parser { } if throwsKeyword != nil && self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { - thrownType = parseThrownType() + thrownType = parseThrownTypeClause() } var unexpectedAfterThrownTypeLoopProgress = LoopProgressCondition() From f3168d0fdf672711f66f4330c0babee0cf881b97 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 10:08:29 -0700 Subject: [PATCH 10/17] Improve parser recovery and diagnostics for typed throws --- Sources/SwiftParser/Specifiers.swift | 10 +- .../ParseDiagnosticsGenerator.swift | 7 +- Tests/SwiftParserTest/DeclarationTests.swift | 109 ++++++++++++++++++ Tests/SwiftParserTest/ExpressionTests.swift | 86 +++++++++++++- Tests/SwiftParserTest/TypeTests.swift | 2 +- 5 files changed, 206 insertions(+), 8 deletions(-) diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index 10bf0741151..ff557adf0eb 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -652,10 +652,10 @@ extension Parser { let (unexpected, throwsKw) = self.eat(handle) unexpectedBeforeThrows.append(contentsOf: unexpected?.elements ?? []) throwsKeyword = throwsKw - } - if throwsKeyword != nil && self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { - thrownType = parseThrownTypeClause() + if self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { + thrownType = parseThrownTypeClause() + } } var unexpectedAfterThrownTypeLoopProgress = LoopProgressCondition() @@ -675,7 +675,9 @@ extension Parser { } } - if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && thrownType == nil && unexpectedAfterThrownType.isEmpty { + if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && thrownType == nil + && unexpectedAfterThrownType.isEmpty + { return nil } diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index 4094bed53c0..0476e0a724c 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -258,7 +258,10 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { (node.throwsSpecifier, { ThrowsEffectSpecifier(token: $0) != nil }, StaticParserError.misspelledThrows), ] - let unexpectedNodes = [node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier,node.unexpectedBetweenThrowsSpecifierAndThrownType, node.unexpectedAfterThrownType] + let unexpectedNodes = [ + node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedBetweenThrowsSpecifierAndThrownType, + node.unexpectedAfterThrownType, + ] // Diagnostics that are emitted later silence previous diagnostics, so check // for the most contextual (and thus helpful) diagnostics last. @@ -279,7 +282,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { } } - if let throwsSpecifier = node.throwsSpecifier, node.thrownType == nil { + if let throwsSpecifier = node.throwsSpecifier { exchangeTokens( unexpected: node.unexpectedAfterThrownType, unexpectedTokenCondition: { AsyncEffectSpecifier(token: $0) != nil }, diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 23fa45138fc..627b122fead 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -905,6 +905,115 @@ final class DeclarationTests: ParserTestCase { """, experimentalFeatures: [.typedThrows] ) + + assertParse( + "func test() throws(MyError) 1️⃣async {}", + diagnostics: [ + DiagnosticSpec(message: "'async' must precede 'throws'", fixIts: ["move 'async' in front of 'throws'"]) + ], + fixedSource: "func test() async throws(MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() throws 1️⃣async2️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "'async' must precede 'throws'", fixIts: ["move 'async' in front of 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in function"), + ], + fixedSource: "func test() async throws (MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() 1️⃣try2️⃣(MyError) async {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "expected throwing specifier; did you mean 'throws'?", fixIts: ["replace 'try' with 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError) async' in function"), + ], + fixedSource: "func test() throws (MyError) async {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() 1️⃣try 2️⃣async3️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "expected throwing specifier; did you mean 'throws'?", fixIts: ["replace 'try' with 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "'async' must precede 'throws'", fixIts: ["move 'async' in front of 'throws'"]), + DiagnosticSpec(locationMarker: "3️⃣", message: "unexpected code '(MyError)' in function"), + ], + fixedSource: "func test() async throws (MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() throws(MyError) 1️⃣await {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "'await' must precede 'throws'", fixIts: ["move 'await' in front of 'throws'"]) + ], + fixedSource: "func test() async throws(MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() throws 1️⃣await2️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "'await' must precede 'throws'", fixIts: ["move 'await' in front of 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in function"), + ], + fixedSource: "func test() async throws (MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() 1️⃣try2️⃣(MyError) await {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "expected throwing specifier; did you mean 'throws'?", fixIts: ["replace 'try' with 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError) await' in function"), + ], + fixedSource: "func test() throws (MyError) await {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() 1️⃣try await2️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "expected throwing specifier; did you mean 'throws'?", fixIts: ["replace 'try' with 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in function"), + ], + fixedSource: "func test() awaitthrows (MyError) {}", // FIXME: spacing + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() async1️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(message: "unexpected code '(MyError)' in function") + ], + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() 1️⃣await2️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "expected async specifier; did you mean 'async'?", fixIts: ["replace 'await' with 'async'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in function"), + ], + fixedSource: "func test() async (MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() 1️⃣try2️⃣(MyError) {}", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "expected throwing specifier; did you mean 'throws'?", fixIts: ["replace 'try' with 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in function"), + ], + fixedSource: "func test() throws (MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() throws(MyError) {}", + experimentalFeatures: [.typedThrows] + ) + assertParse( + "func test() throws(MyError)1️⃣async {}", // no space between closing parenthesis and `async` + diagnostics: [ + DiagnosticSpec(message: "'async' must precede 'throws'", fixIts: ["move 'async' in front of 'throws'"]) + ], + fixedSource: "func test() async throws(MyError){}", + experimentalFeatures: [.typedThrows] + ) } func testExtraneousRightBraceRecovery() { diff --git a/Tests/SwiftParserTest/ExpressionTests.swift b/Tests/SwiftParserTest/ExpressionTests.swift index 24880439f82..6f400ea68a0 100644 --- a/Tests/SwiftParserTest/ExpressionTests.swift +++ b/Tests/SwiftParserTest/ExpressionTests.swift @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -@_spi(RawSyntax) import SwiftParser +@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftParser @_spi(RawSyntax) import SwiftSyntax import XCTest @@ -2742,4 +2742,88 @@ final class StatementExpressionTests: ParserTestCase { """ ) } + + func testTypedThrowsDisambiguation() { + assertParse( + "[() throws(MyError) 1️⃣async -> Void]()", + diagnostics: [ + DiagnosticSpec(message: "'async' must precede 'throws'", fixIts: ["move 'async' in front of 'throws'"]) + ], + fixedSource: "[() async throws(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() throws 1️⃣async2️⃣(MyError) -> Void]()", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "'async' must precede 'throws'", fixIts: ["move 'async' in front of 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in array element"), + ], + fixedSource: "[() async throws (MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() try(MyError) async -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() try async(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() throws(MyError) 1️⃣await -> Void]()", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "'await' must precede 'throws'", fixIts: ["move 'await' in front of 'throws'"]) + ], + fixedSource: "[() async throws(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() throws 1️⃣await2️⃣(MyError) -> Void]()", + diagnostics: [ + DiagnosticSpec(locationMarker: "1️⃣", message: "'await' must precede 'throws'", fixIts: ["move 'await' in front of 'throws'"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '(MyError)' in array element"), + ], + fixedSource: "[() async throws (MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() try(MyError) await 1️⃣-> Void]()", + diagnostics: [ + DiagnosticSpec( + message: "expected expression in 'await' expression", + fixIts: ["insert expression"] + ) + ], + fixedSource: "[() try(MyError) await <#expression#> -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() try await(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() async(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() await(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() try(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "[() throws(MyError) -> Void]()", + experimentalFeatures: .typedThrows + ) + assertParse( + "X<() throws(MyError) -> Int>()", + experimentalFeatures: .typedThrows + ) + assertParse( + "X<() async throws(MyError) -> Int>()", + experimentalFeatures: .typedThrows + ) + } } diff --git a/Tests/SwiftParserTest/TypeTests.swift b/Tests/SwiftParserTest/TypeTests.swift index 563e4713011..73f3c4f3605 100644 --- a/Tests/SwiftParserTest/TypeTests.swift +++ b/Tests/SwiftParserTest/TypeTests.swift @@ -10,7 +10,7 @@ // //===----------------------------------------------------------------------===// -@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftParser +@_spi(RawSyntax) @_spi(ExperimentalLanguageFeatures) import SwiftParser @_spi(RawSyntax) import SwiftSyntax import XCTest From 9d7be37d0a26f7499d987cd5d22827999a54aca9 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 12:52:20 -0700 Subject: [PATCH 11/17] Support building resilient libraries with @_spi default implementation --- Sources/SwiftSyntax/SyntaxProtocol.swift | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/Sources/SwiftSyntax/SyntaxProtocol.swift b/Sources/SwiftSyntax/SyntaxProtocol.swift index 1f54379c9db..83ea1001ef5 100644 --- a/Sources/SwiftSyntax/SyntaxProtocol.swift +++ b/Sources/SwiftSyntax/SyntaxProtocol.swift @@ -733,3 +733,14 @@ public extension SyntaxChildChoices { return self.as(S.self)! } } + + +extension EffectSpecifiersSyntax { + // Default implementation for the experimental thrownType child, which must + // be provided due to the use of @_spi. + @_spi(ExperimentalLanguageFeatures) + public var thrownType: ThrownTypeClauseSyntax? { + get { return nil } + set { } + } +} From 1df2e44ca1d18c6abd0ec73dbc6a5a6368e42cab Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 17:19:33 -0700 Subject: [PATCH 12/17] Address test failures be renaming child nodes and adding a trait --- CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift | 9 ++++++--- CodeGeneration/Sources/SyntaxSupport/Traits.swift | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index 74a88705cc8..38541ffb540 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -84,6 +84,9 @@ public let COMMON_NODES: [Node] = [ base: .syntax, nameForDiagnostics: "thrown type clause", documentation: "The specific error type that a function can throw.", + traits: [ + "Parenthesized", + ], children: [ Child( name: "leftParen", @@ -125,7 +128,7 @@ public let COMMON_NODES: [Node] = [ isOptional: true ), Child( - name: "thrownType", + name: "thrownError", kind: .node(kind: .thrownTypeClause), experimentalFeature: .typedThrows, documentation: "The specific error type thrown by this accessor.", @@ -155,7 +158,7 @@ public let COMMON_NODES: [Node] = [ isOptional: true ), Child( - name: "thrownType", + name: "thrownError", kind: .node(kind: .thrownTypeClause), experimentalFeature: .typedThrows, documentation: "The specific error type thrown by this function.", @@ -364,7 +367,7 @@ public let COMMON_NODES: [Node] = [ isOptional: true ), Child( - name: "thrownType", + name: "thrownError", kind: .node(kind: .thrownTypeClause), experimentalFeature: .typedThrows, documentation: "The specific error type thrown by this function type.", diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index 190aa571c5a..343ff1c42f4 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -58,7 +58,7 @@ public let TRAITS: [Trait] = [ Child(name: "throwsSpecifier", kind: .token(choices: [.keyword(.throws), .keyword(.rethrows)]), isOptional: true), Child(name: "unexpectedBetweenThrowsSpecifierAndThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), Child( - name: "thrownType", + name: "thrownError", kind: .node(kind: .thrownTypeClause), experimentalFeature: .typedThrows, documentation: "The specific thrown error type.", From 204162a460766a164c6308533439d9289d6151a9 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 17:21:01 -0700 Subject: [PATCH 13/17] Regenerate --- .../generated/ChildNameForKeyPath.swift | 36 ++++++++--------- .../SwiftSyntax/generated/SyntaxTraits.swift | 4 +- .../generated/raw/RawSyntaxNodesAB.swift | 18 ++++----- .../generated/raw/RawSyntaxNodesEF.swift | 18 ++++----- .../generated/raw/RawSyntaxNodesTUVWXYZ.swift | 18 ++++----- .../generated/syntaxNodes/SyntaxNodesAB.swift | 34 ++++++++-------- .../generated/syntaxNodes/SyntaxNodesEF.swift | 34 ++++++++-------- .../syntaxNodes/SyntaxNodesTUVWXYZ.swift | 40 +++++++++---------- 8 files changed, 102 insertions(+), 100 deletions(-) diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index 1d472b71121..42fe4314264 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -65,12 +65,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" case \AccessorEffectSpecifiersSyntax.throwsSpecifier: return "throwsSpecifier" - case \AccessorEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType: - return "unexpectedBetweenThrowsSpecifierAndThrownType" - case \AccessorEffectSpecifiersSyntax.thrownType: - return "thrownType" - case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrownType: - return "unexpectedAfterThrownType" + case \AccessorEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownError: + return "unexpectedBetweenThrowsSpecifierAndThrownError" + case \AccessorEffectSpecifiersSyntax.thrownError: + return "thrownError" + case \AccessorEffectSpecifiersSyntax.unexpectedAfterThrownError: + return "unexpectedAfterThrownError" case \AccessorParametersSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \AccessorParametersSyntax.leftParen: @@ -1405,12 +1405,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" case \FunctionEffectSpecifiersSyntax.throwsSpecifier: return "throwsSpecifier" - case \FunctionEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType: - return "unexpectedBetweenThrowsSpecifierAndThrownType" - case \FunctionEffectSpecifiersSyntax.thrownType: - return "thrownType" - case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrownType: - return "unexpectedAfterThrownType" + case \FunctionEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownError: + return "unexpectedBetweenThrowsSpecifierAndThrownError" + case \FunctionEffectSpecifiersSyntax.thrownError: + return "thrownError" + case \FunctionEffectSpecifiersSyntax.unexpectedAfterThrownError: + return "unexpectedAfterThrownError" case \FunctionParameterClauseSyntax.unexpectedBeforeLeftParen: return "unexpectedBeforeLeftParen" case \FunctionParameterClauseSyntax.leftParen: @@ -3257,12 +3257,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAsyncSpecifierAndThrowsSpecifier" case \TypeEffectSpecifiersSyntax.throwsSpecifier: return "throwsSpecifier" - case \TypeEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownType: - return "unexpectedBetweenThrowsSpecifierAndThrownType" - case \TypeEffectSpecifiersSyntax.thrownType: - return "thrownType" - case \TypeEffectSpecifiersSyntax.unexpectedAfterThrownType: - return "unexpectedAfterThrownType" + case \TypeEffectSpecifiersSyntax.unexpectedBetweenThrowsSpecifierAndThrownError: + return "unexpectedBetweenThrowsSpecifierAndThrownError" + case \TypeEffectSpecifiersSyntax.thrownError: + return "thrownError" + case \TypeEffectSpecifiersSyntax.unexpectedAfterThrownError: + return "unexpectedAfterThrownError" case \TypeExprSyntax.unexpectedBeforeType: return "unexpectedBeforeType" case \TypeExprSyntax.type: diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index c98e81d0857..42f892340d3 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -159,7 +159,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { /// The specific thrown error type. @_spi(ExperimentalLanguageFeatures) - var thrownType: ThrownTypeClauseSyntax? { + var thrownError: ThrownTypeClauseSyntax? { get set } @@ -803,6 +803,8 @@ extension SwitchCaseSyntax: WithStatementsSyntax {} extension SwitchExprSyntax: BracedSyntax {} +extension ThrownTypeClauseSyntax: ParenthesizedSyntax {} + extension TupleExprSyntax: ParenthesizedSyntax {} extension TuplePatternElementSyntax: WithTrailingCommaSyntax {} diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift index b46c32f8c7e..3ccb2034184 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift @@ -312,9 +312,9 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, - thrownType: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? = nil, + thrownError: RawThrownTypeClauseSyntax?, + _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( @@ -324,9 +324,9 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layout[1] = asyncSpecifier?.raw layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw layout[3] = throwsSpecifier?.raw - layout[4] = unexpectedBetweenThrowsSpecifierAndThrownType?.raw - layout[5] = thrownType?.raw - layout[6] = unexpectedAfterThrownType?.raw + layout[4] = unexpectedBetweenThrowsSpecifierAndThrownError?.raw + layout[5] = thrownError?.raw + layout[6] = unexpectedAfterThrownError?.raw } self.init(unchecked: raw) } @@ -347,15 +347,15 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var thrownType: RawThrownTypeClauseSyntax? { + public var thrownError: RawThrownTypeClauseSyntax? { layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) } - public var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { + public var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift index 92b81a2a656..51ab9c4f6ae 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift @@ -2002,9 +2002,9 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, - thrownType: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? = nil, + thrownError: RawThrownTypeClauseSyntax?, + _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( @@ -2014,9 +2014,9 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layout[1] = asyncSpecifier?.raw layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw layout[3] = throwsSpecifier?.raw - layout[4] = unexpectedBetweenThrowsSpecifierAndThrownType?.raw - layout[5] = thrownType?.raw - layout[6] = unexpectedAfterThrownType?.raw + layout[4] = unexpectedBetweenThrowsSpecifierAndThrownError?.raw + layout[5] = thrownError?.raw + layout[6] = unexpectedAfterThrownError?.raw } self.init(unchecked: raw) } @@ -2037,15 +2037,15 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var thrownType: RawThrownTypeClauseSyntax? { + public var thrownError: RawThrownTypeClauseSyntax? { layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) } - public var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { + public var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift index 1a0cd8311d6..a7317d6c413 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift @@ -1218,9 +1218,9 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil, throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? = nil, - thrownType: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? = nil, + thrownError: RawThrownTypeClauseSyntax?, + _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( @@ -1230,9 +1230,9 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layout[1] = asyncSpecifier?.raw layout[2] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw layout[3] = throwsSpecifier?.raw - layout[4] = unexpectedBetweenThrowsSpecifierAndThrownType?.raw - layout[5] = thrownType?.raw - layout[6] = unexpectedAfterThrownType?.raw + layout[4] = unexpectedBetweenThrowsSpecifierAndThrownError?.raw + layout[5] = thrownError?.raw + layout[6] = unexpectedAfterThrownError?.raw } self.init(unchecked: raw) } @@ -1253,15 +1253,15 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { layoutView.children[3].map(RawTokenSyntax.init(raw:)) } - public var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } - public var thrownType: RawThrownTypeClauseSyntax? { + public var thrownError: RawThrownTypeClauseSyntax? { layoutView.children[5].map(RawThrownTypeClauseSyntax.init(raw:)) } - public var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { + public var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index 6044a5a4974..cdcc5a8960f 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -525,7 +525,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// /// - `asyncSpecifier`: `async`? /// - `throwsSpecifier`: `throws`? -/// - `thrownType`: ``ThrownTypeClauseSyntax``? +/// - `thrownError`: ``ThrownTypeClauseSyntax``? /// /// ### Contained in /// @@ -544,7 +544,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// - 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. - /// - thrownType: The specific error type thrown by this accessor. + /// - thrownError: The specific error type thrown by this accessor. /// - 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, @@ -552,9 +552,9 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier: TokenSyntax? = nil, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, - thrownType: ThrownTypeClauseSyntax? = nil, - _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? = nil, + thrownError: ThrownTypeClauseSyntax? = nil, + _ unexpectedAfterThrownError: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -565,18 +565,18 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndThrownType, - thrownType, - unexpectedAfterThrownType + unexpectedBetweenThrowsSpecifierAndThrownError, + thrownError, + unexpectedAfterThrownError ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, throwsSpecifier?.raw, - unexpectedBetweenThrowsSpecifierAndThrownType?.raw, - thrownType?.raw, - unexpectedAfterThrownType?.raw + unexpectedBetweenThrowsSpecifierAndThrownError?.raw, + thrownError?.raw, + unexpectedAfterThrownError?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorEffectSpecifiers, @@ -636,7 +636,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -647,7 +647,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// The specific error type thrown by this accessor. @_spi(ExperimentalLanguageFeatures) - public var thrownType: ThrownTypeClauseSyntax? { + public var thrownError: ThrownTypeClauseSyntax? { get { return Syntax(self).child(at: 5)?.cast(ThrownTypeClauseSyntax.self) } @@ -656,7 +656,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedAfterThrownType: UnexpectedNodesSyntax? { + public var unexpectedAfterThrownError: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } @@ -671,9 +671,9 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L \Self.asyncSpecifier, \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, \Self.throwsSpecifier, - \Self.unexpectedBetweenThrowsSpecifierAndThrownType, - \Self.thrownType, - \Self.unexpectedAfterThrownType + \Self.unexpectedBetweenThrowsSpecifierAndThrownError, + \Self.thrownError, + \Self.unexpectedAfterThrownError ]) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index 6b2a11ba55b..ef2bf67687c 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -3703,7 +3703,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS /// /// - `asyncSpecifier`: (`async` | `reasync`)? /// - `throwsSpecifier`: (`throws` | `rethrows`)? -/// - `thrownType`: ``ThrownTypeClauseSyntax``? +/// - `thrownError`: ``ThrownTypeClauseSyntax``? /// /// ### Contained in /// @@ -3722,7 +3722,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// - 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. - /// - thrownType: The specific error type thrown by this function. + /// - thrownError: The specific error type thrown by this function. /// - 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, @@ -3730,9 +3730,9 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier: TokenSyntax? = nil, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, - thrownType: ThrownTypeClauseSyntax? = nil, - _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? = nil, + thrownError: ThrownTypeClauseSyntax? = nil, + _ unexpectedAfterThrownError: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3743,18 +3743,18 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L asyncSpecifier, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndThrownType, - thrownType, - unexpectedAfterThrownType + unexpectedBetweenThrowsSpecifierAndThrownError, + thrownError, + unexpectedAfterThrownError ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, throwsSpecifier?.raw, - unexpectedBetweenThrowsSpecifierAndThrownType?.raw, - thrownType?.raw, - unexpectedAfterThrownType?.raw + unexpectedBetweenThrowsSpecifierAndThrownError?.raw, + thrownError?.raw, + unexpectedAfterThrownError?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionEffectSpecifiers, @@ -3818,7 +3818,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -3829,7 +3829,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L /// The specific error type thrown by this function. @_spi(ExperimentalLanguageFeatures) - public var thrownType: ThrownTypeClauseSyntax? { + public var thrownError: ThrownTypeClauseSyntax? { get { return Syntax(self).child(at: 5)?.cast(ThrownTypeClauseSyntax.self) } @@ -3838,7 +3838,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L } } - public var unexpectedAfterThrownType: UnexpectedNodesSyntax? { + public var unexpectedAfterThrownError: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } @@ -3853,9 +3853,9 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L \Self.asyncSpecifier, \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, \Self.throwsSpecifier, - \Self.unexpectedBetweenThrowsSpecifierAndThrownType, - \Self.thrownType, - \Self.unexpectedAfterThrownType + \Self.unexpectedBetweenThrowsSpecifierAndThrownError, + \Self.thrownError, + \Self.unexpectedAfterThrownError ]) } } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift index bfbc009ade9..8abf8e3e7ca 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift @@ -480,9 +480,9 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt /// /// ### Contained in /// -/// - ``AccessorEffectSpecifiersSyntax``.``AccessorEffectSpecifiersSyntax/thrownType`` -/// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/thrownType`` -/// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/thrownType`` +/// - ``AccessorEffectSpecifiersSyntax``.``AccessorEffectSpecifiersSyntax/thrownError`` +/// - ``FunctionEffectSpecifiersSyntax``.``FunctionEffectSpecifiersSyntax/thrownError`` +/// - ``TypeEffectSpecifiersSyntax``.``TypeEffectSpecifiersSyntax/thrownError`` public struct ThrownTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol { public let _syntaxNode: Syntax @@ -2242,7 +2242,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN /// /// - `asyncSpecifier`: `async`? /// - `throwsSpecifier`: `throws`? -/// - `thrownType`: ``ThrownTypeClauseSyntax``? +/// - `thrownError`: ``ThrownTypeClauseSyntax``? /// /// ### Contained in /// @@ -2261,7 +2261,7 @@ 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. - /// - thrownType: The specific error type thrown by this function type. + /// - thrownError: The specific error type thrown by this function type. /// - 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, @@ -2269,9 +2269,9 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS asyncSpecifier: TokenSyntax? = nil, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, throwsSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? = nil, - thrownType: ThrownTypeClauseSyntax? = nil, - _ unexpectedAfterThrownType: UnexpectedNodesSyntax? = nil, + _ unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? = nil, + thrownError: ThrownTypeClauseSyntax? = nil, + _ unexpectedAfterThrownError: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2282,18 +2282,18 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS asyncSpecifier, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndThrownType, - thrownType, - unexpectedAfterThrownType + unexpectedBetweenThrowsSpecifierAndThrownError, + thrownError, + unexpectedAfterThrownError ))) { (arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.raw, throwsSpecifier?.raw, - unexpectedBetweenThrowsSpecifierAndThrownType?.raw, - thrownType?.raw, - unexpectedAfterThrownType?.raw + unexpectedBetweenThrowsSpecifierAndThrownError?.raw, + thrownError?.raw, + unexpectedAfterThrownError?.raw ] let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeEffectSpecifiers, @@ -2349,7 +2349,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - public var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { + public var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self) } @@ -2360,7 +2360,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS /// The specific error type thrown by this function type. @_spi(ExperimentalLanguageFeatures) - public var thrownType: ThrownTypeClauseSyntax? { + public var thrownError: ThrownTypeClauseSyntax? { get { return Syntax(self).child(at: 5)?.cast(ThrownTypeClauseSyntax.self) } @@ -2369,7 +2369,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS } } - public var unexpectedAfterThrownType: UnexpectedNodesSyntax? { + public var unexpectedAfterThrownError: UnexpectedNodesSyntax? { get { return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self) } @@ -2384,9 +2384,9 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS \Self.asyncSpecifier, \Self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, \Self.throwsSpecifier, - \Self.unexpectedBetweenThrowsSpecifierAndThrownType, - \Self.thrownType, - \Self.unexpectedAfterThrownType + \Self.unexpectedBetweenThrowsSpecifierAndThrownError, + \Self.thrownError, + \Self.unexpectedAfterThrownError ]) } } From 011ddd91e9e7ad423b5513fb8065bc270b3e153d Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 17:26:23 -0700 Subject: [PATCH 14/17] Adjust to renames --- .../Sources/SyntaxSupport/CommonNodes.swift | 2 +- Sources/SwiftParser/Specifiers.swift | 54 +++++++++---------- .../ParseDiagnosticsGenerator.swift | 6 +-- Sources/SwiftSyntax/SyntaxProtocol.swift | 7 ++- .../SwiftSyntax/generated/SyntaxTraits.swift | 4 +- 5 files changed, 36 insertions(+), 37 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index 38541ffb540..9ba842e6bef 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -85,7 +85,7 @@ public let COMMON_NODES: [Node] = [ nameForDiagnostics: "thrown type clause", documentation: "The specific error type that a function can throw.", traits: [ - "Parenthesized", + "Parenthesized" ], children: [ Child( diff --git a/Sources/SwiftParser/Specifiers.swift b/Sources/SwiftParser/Specifiers.swift index ff557adf0eb..66f7682616a 100644 --- a/Sources/SwiftParser/Specifiers.swift +++ b/Sources/SwiftParser/Specifiers.swift @@ -160,12 +160,12 @@ protocol RawMisplacedEffectSpecifiersTrait { var asyncSpecifier: RawTokenSyntax? { get } var throwsSpecifier: RawTokenSyntax? { get } - var thrownType: RawThrownTypeClauseSyntax? { get } + var thrownError: RawThrownTypeClauseSyntax? { get } init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, - thrownType: RawThrownTypeClauseSyntax?, + thrownError: RawThrownTypeClauseSyntax?, arena: __shared SyntaxArena ) @@ -175,17 +175,17 @@ protocol RawMisplacedEffectSpecifiersTrait { protocol RawEffectSpecifiersTrait: RawMisplacedEffectSpecifiersTrait { var unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? { get } var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? { get } - var unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax? { get } - var thrownType: RawThrownTypeClauseSyntax? { get } - var unexpectedAfterThrownType: RawUnexpectedNodesSyntax? { get } + var unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax? { get } + var thrownError: RawThrownTypeClauseSyntax? { get } + var unexpectedAfterThrownError: RawUnexpectedNodesSyntax? { get } init( _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax?, asyncSpecifier: RawTokenSyntax?, _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax?, throwsSpecifier: RawTokenSyntax?, - _ unexpectedBetweenThrowsSpecifierAndThrownType: RawUnexpectedNodesSyntax?, - thrownType: RawThrownTypeClauseSyntax?, - _ unexpectedAfterThrownType: RawUnexpectedNodesSyntax?, + _ unexpectedBetweenThrowsSpecifierAndThrownError: RawUnexpectedNodesSyntax?, + thrownError: RawThrownTypeClauseSyntax?, + _ unexpectedAfterThrownError: RawUnexpectedNodesSyntax?, arena: __shared SyntaxArena ) } @@ -194,7 +194,7 @@ extension RawEffectSpecifiersTrait { init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, - thrownType: RawThrownTypeClauseSyntax?, + thrownError: RawThrownTypeClauseSyntax?, arena: __shared SyntaxArena ) { self.init( @@ -203,7 +203,7 @@ extension RawEffectSpecifiersTrait { nil, throwsSpecifier: throwsSpecifier, nil, - thrownType: thrownType, + thrownError: thrownError, nil, arena: arena ) @@ -215,9 +215,9 @@ extension RawEffectSpecifiersTrait { asyncSpecifier: self.asyncSpecifier ?? misplacedAsyncKeyword, self.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier: self.throwsSpecifier ?? misplacedThrowsKeyword, - self.unexpectedBetweenThrowsSpecifierAndThrownType, - thrownType: thrownType, - self.unexpectedAfterThrownType, + self.unexpectedBetweenThrowsSpecifierAndThrownError, + thrownError: thrownError, + self.unexpectedAfterThrownError, arena: arena ) } @@ -538,12 +538,12 @@ extension RawDeinitializerEffectSpecifiersSyntax: RawMisplacedEffectSpecifiersTr } var throwsSpecifier: RawTokenSyntax? { nil } - var thrownType: RawThrownTypeClauseSyntax? { nil } + var thrownError: RawThrownTypeClauseSyntax? { nil } init( asyncSpecifier: RawTokenSyntax?, throwsSpecifier: RawTokenSyntax?, - thrownType: RawThrownTypeClauseSyntax?, + thrownError: RawThrownTypeClauseSyntax?, arena: __shared SwiftSyntax.SyntaxArena ) { // `throwsSpecifier` should never be present because `parseMisplacedEffectSpecifiers()` only creates missing tokens @@ -615,8 +615,8 @@ extension Parser { var asyncKeyword: RawTokenSyntax? = nil var unexpectedBeforeThrows: [RawSyntax] = [] var throwsKeyword: RawTokenSyntax? - var thrownType: RawThrownTypeClauseSyntax? - var unexpectedAfterThrownType: [RawSyntax] = [] + var thrownError: RawThrownTypeClauseSyntax? + var unexpectedAfterThrownError: [RawSyntax] = [] while let misspelledAsync = self.consume(ifAnyIn: S.MisspelledAsyncTokenKinds.self) { unexpectedBeforeAsync.append(RawSyntax(misspelledAsync)) @@ -654,29 +654,29 @@ extension Parser { throwsKeyword = throwsKw if self.at(.leftParen) && experimentalFeatures.contains(.typedThrows) { - thrownType = parseThrownTypeClause() + thrownError = parseThrownTypeClause() } } - var unexpectedAfterThrownTypeLoopProgress = LoopProgressCondition() - while self.hasProgressed(&unexpectedAfterThrownTypeLoopProgress) { + var unexpectedAfterThrownErrorLoopProgress = LoopProgressCondition() + while self.hasProgressed(&unexpectedAfterThrownErrorLoopProgress) { if let (_, handle, _) = self.at(anyIn: S.MisspelledAsyncTokenKinds.self, or: S.CorrectAsyncTokenKinds.self) { let misspelledAsync = self.eat(handle) - unexpectedAfterThrownType.append(RawSyntax(misspelledAsync)) + unexpectedAfterThrownError.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) - unexpectedAfterThrownType.append(RawSyntax(misspelledThrows)) + unexpectedAfterThrownError.append(RawSyntax(misspelledThrows)) } else { break } } - if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && thrownType == nil - && unexpectedAfterThrownType.isEmpty + if unexpectedBeforeAsync.isEmpty && asyncKeyword == nil && unexpectedBeforeThrows.isEmpty && throwsKeyword == nil && thrownError == nil + && unexpectedAfterThrownError.isEmpty { return nil } @@ -687,8 +687,8 @@ extension Parser { RawUnexpectedNodesSyntax(unexpectedBeforeThrows, arena: self.arena), throwsSpecifier: throwsKeyword, nil, - thrownType: thrownType, - RawUnexpectedNodesSyntax(unexpectedAfterThrownType, arena: self.arena), + thrownError: thrownError, + RawUnexpectedNodesSyntax(unexpectedAfterThrownError, arena: self.arena), arena: self.arena ) } @@ -792,7 +792,7 @@ extension Parser { effectSpecifiers = S( asyncSpecifier: synthesizedAsync, throwsSpecifier: synthesizedThrows, - thrownType: nil, + thrownError: nil, arena: self.arena ) } diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index 0476e0a724c..2c8f339176d 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -259,8 +259,8 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { ] let unexpectedNodes = [ - node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedBetweenThrowsSpecifierAndThrownType, - node.unexpectedAfterThrownType, + node.unexpectedBeforeAsyncSpecifier, node.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, node.unexpectedBetweenThrowsSpecifierAndThrownError, + node.unexpectedAfterThrownError, ] // 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.unexpectedAfterThrownType, + unexpected: node.unexpectedAfterThrownError, 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 83ea1001ef5..2be9d451a25 100644 --- a/Sources/SwiftSyntax/SyntaxProtocol.swift +++ b/Sources/SwiftSyntax/SyntaxProtocol.swift @@ -734,13 +734,12 @@ public extension SyntaxChildChoices { } } - extension EffectSpecifiersSyntax { - // Default implementation for the experimental thrownType child, which must + // Default implementation for the experimental thrownError child, which must // be provided due to the use of @_spi. @_spi(ExperimentalLanguageFeatures) - public var thrownType: ThrownTypeClauseSyntax? { + public var thrownError: ThrownTypeClauseSyntax? { get { return nil } - set { } + set {} } } diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index 42f892340d3..e86a2cbf8c9 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -152,7 +152,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { + var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { get set } @@ -164,7 +164,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedAfterThrownType: UnexpectedNodesSyntax? { + var unexpectedAfterThrownError: UnexpectedNodesSyntax? { get set } From 15ae54e7e483f01483dbeb74ead2c62116c57451 Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 22:41:48 -0700 Subject: [PATCH 15/17] Regenerate --- Sources/SwiftSyntax/generated/SyntaxTraits.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index e86a2cbf8c9..42f892340d3 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -152,7 +152,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { + var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { get set } @@ -164,7 +164,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedAfterThrownError: UnexpectedNodesSyntax? { + var unexpectedAfterThrownType: UnexpectedNodesSyntax? { get set } From a3c2de2d41840c3b343cf578c0f406a0220c1fea Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Fri, 29 Sep 2023 23:05:31 -0700 Subject: [PATCH 16/17] Finish fixup after regeneration --- Sources/SwiftSyntax/generated/SyntaxTraits.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index 42f892340d3..e86a2cbf8c9 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -152,7 +152,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedBetweenThrowsSpecifierAndThrownType: UnexpectedNodesSyntax? { + var unexpectedBetweenThrowsSpecifierAndThrownError: UnexpectedNodesSyntax? { get set } @@ -164,7 +164,7 @@ public protocol EffectSpecifiersSyntax: SyntaxProtocol { set } - var unexpectedAfterThrownType: UnexpectedNodesSyntax? { + var unexpectedAfterThrownError: UnexpectedNodesSyntax? { get set } From b2432601dc53a426d872a06a092a89db1b207e8f Mon Sep 17 00:00:00 2001 From: Doug Gregor Date: Sat, 30 Sep 2023 08:42:15 -0700 Subject: [PATCH 17/17] Renames for consistency in EffectSpecifiers --- CodeGeneration/Sources/SyntaxSupport/Traits.swift | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift index 343ff1c42f4..41aca45d145 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift @@ -56,7 +56,7 @@ public let TRAITS: [Trait] = [ 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: "unexpectedBetweenThrowsSpecifierAndThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), + Child(name: "unexpectedBetweenThrowsSpecifierAndThrownError", kind: .node(kind: .unexpectedNodes), isOptional: true), Child( name: "thrownError", kind: .node(kind: .thrownTypeClause), @@ -64,7 +64,7 @@ public let TRAITS: [Trait] = [ documentation: "The specific thrown error type.", isOptional: true ), - Child(name: "unexpectedAfterThrownType", kind: .node(kind: .unexpectedNodes), isOptional: true), + Child(name: "unexpectedAfterThrownError", kind: .node(kind: .unexpectedNodes), isOptional: true), ] ), Trait(