diff --git a/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift b/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift index 4889bf1d639..669128bceeb 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/GenerateSwiftSyntax.swift @@ -128,7 +128,15 @@ struct GenerateSwiftSyntax: AsyncParsableCommand { GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxCollections.swift"], syntaxCollectionsFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxEnum.swift"], syntaxEnumFile), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxKind.swift"], syntaxKindFile), - GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxRewriter.swift"], syntaxRewriterFile), + GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxRewriter.swift"], syntaxRewriterFile()), + GeneratedFileSpec( + swiftSyntaxGeneratedDir + ["AsyncSyntaxRewriter.swift"], + syntaxRewriterFile( + className: "AsyncSyntaxRewriter", + functionEffectSpecifiers: "async", + functionCallOperators: "await" + ) + ), GeneratedFileSpec(swiftSyntaxGeneratedDir + ["SyntaxTraits.swift"], syntaxTraitsFile), GeneratedFileSpec( swiftSyntaxGeneratedDir + ["SyntaxVisitor.swift"], diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SwiftSyntaxDoccIndexTemplate.md b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SwiftSyntaxDoccIndexTemplate.md index 90a6b5df14b..527e76ce810 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SwiftSyntaxDoccIndexTemplate.md +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SwiftSyntaxDoccIndexTemplate.md @@ -54,6 +54,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax - - - +- - - - diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewriterFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewriterFile.swift deleted file mode 100644 index 4d391f7b669..00000000000 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewriterFile.swift +++ /dev/null @@ -1,370 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -import SwiftSyntax -import SwiftSyntaxBuilder -import SyntaxSupport -import Utils - -let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { - try! ClassDeclSyntax( - """ - // - // This file defines the SyntaxRewriter, a class that performs a standard walk - // and tree-rebuilding pattern. - // - // Subclassers of this class can override the walking behavior for any syntax - // node and transform nodes however they like. - // - //===----------------------------------------------------------------------===// - - open class SyntaxRewriter - """ - ) { - DeclSyntax("public let viewMode: SyntaxTreeViewMode") - DeclSyntax( - """ - /// The arena in which the parents of rewritten nodes should be allocated. - /// - /// The `SyntaxRewriter` subclass is responsible for generating the rewritten nodes. To incorporate them into the - /// tree, all of the rewritten node's parents also need to be re-created. This is the arena in which those - /// intermediate nodes should be allocated. - private let arena: SyntaxArena? - """ - ) - - DeclSyntax( - """ - /// 'Syntax' object factory recycling 'Syntax.Info' instances. - private let nodeFactory: SyntaxNodeFactory = SyntaxNodeFactory() - """ - ) - - DeclSyntax( - """ - public init(viewMode: SyntaxTreeViewMode = .sourceAccurate) { - self.viewMode = viewMode - self.arena = nil - } - """ - ) - - DeclSyntax( - """ - @_spi(RawSyntax) - public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, arena: SyntaxArena? = nil) { - self.viewMode = viewMode - self.arena = arena - } - """ - ) - - DeclSyntax( - """ - /// Rewrite `node`, keeping its parent unless `detach` is `true`. - public func rewrite(_ node: some SyntaxProtocol, detach: Bool = false) -> Syntax { - var rewritten = Syntax(node) - self.dispatchVisit(&rewritten) - if detach { - return rewritten - } - - return withExtendedLifetime(rewritten) { - return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, allocationArena: SyntaxArena()) - } - } - """ - ) - - DeclSyntax( - """ - /// Visit a ``TokenSyntax``. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - open func visit(_ token: TokenSyntax) -> TokenSyntax { - return token - } - """ - ) - - DeclSyntax( - """ - /// The function called before visiting the node and its descendants. - /// - node: the node we are about to visit. - open func visitPre(_ node: Syntax) {} - """ - ) - - DeclSyntax( - """ - /// Override point to choose custom visitation dispatch instead of the - /// specialized `visit(_:)` methods. Use this instead of those methods if - /// you intend to dynamically dispatch rewriting behavior. - /// - note: If this method returns a non-nil result, the subsequent - /// `visitAny(_:)` methods and the specialized `visit(_:)` - /// methods will not be called for this node and the - /// visited node will be replaced by the returned node in the - /// rewritten tree. - /// You can call the ``SyntaxRewriter/rewrite(_:detach:)`` - /// method recursively when returning a non-nil result - /// if you want to visit the node's children anyway. - open func visitAny(_ node: Syntax) -> Syntax? { - return nil - } - """ - ) - - DeclSyntax( - """ - /// The function called after visiting the node and its descendants. - /// - node: the node we just finished visiting. - open func visitPost(_ node: Syntax) {} - """ - ) - - DeclSyntax( - """ - /// Visit any Syntax node. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - @available(*, deprecated, renamed: "rewrite(_:detach:)") - public func visit(_ node: Syntax) -> Syntax { - var rewritten = node - dispatchVisit(&rewritten) - return rewritten - } - """ - ) - - DeclSyntax( - """ - public func visit(_ node: T) -> T { - var rewritten = Syntax(node) - dispatchVisit(&rewritten) - return rewritten.cast(T.self) - } - """ - ) - - for node in SYNTAX_NODES where !node.kind.isBase { - if (node.base == .syntax || node.base == .syntaxCollection) && node.kind != .missing { - DeclSyntax( - """ - /// Visit a \(raw: node.kind.doccLink). - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - \(node.apiAttributes())\ - open func visit(_ node: \(node.kind.syntaxType)) -> \(node.kind.syntaxType) { - return visitChildren(node._syntaxNode).cast(\(node.kind.syntaxType).self) - } - """ - ) - } else { - DeclSyntax( - """ - /// Visit a \(raw: node.kind.doccLink). - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - \(node.apiAttributes())\ - open func visit(_ node: \(node.kind.syntaxType)) -> \(node.baseType.syntaxBaseName) { - return \(node.baseType.syntaxBaseName)(visitChildren(node._syntaxNode).cast(\(node.kind.syntaxType).self)) - } - """ - ) - } - } - - for baseNode in SYNTAX_NODES - where baseNode.kind.isBase && baseNode.kind != .syntax && baseNode.kind != .syntaxCollection { - let baseKind = baseNode.kind - DeclSyntax( - """ - /// Visit any \(baseKind.syntaxType) node. - /// - Parameter node: the node that is being visited - /// - Returns: the rewritten node - \(baseNode.apiAttributes())\ - public func visit(_ node: \(baseKind.syntaxType)) -> \(baseKind.syntaxType) { - var node: Syntax = Syntax(node) - dispatchVisit(&node) - return node.cast(\(baseKind.syntaxType).self) - } - """ - ) - } - - DeclSyntax( - """ - /// Interpret `node` as a node of type `nodeType`, visit it, calling - /// the `visit` to transform the node. - @inline(__always) - private func visitImpl( - _ node: inout Syntax, - _ nodeType: NodeType.Type, - _ visit: (NodeType) -> some SyntaxProtocol - ) { - let origNode = node - visitPre(origNode) - node = visitAny(origNode) ?? Syntax(visit(origNode.cast(NodeType.self))) - visitPost(origNode) - } - """ - ) - - try IfConfigDeclSyntax( - leadingTrivia: - """ - // SwiftSyntax requires a lot of stack space in debug builds for syntax tree - // rewriting. In scenarios with reduced stack space (in particular dispatch - // queues), this easily results in a stack overflow. To work around this issue, - // use a less performant but also less stack-hungry version of SwiftSyntax's - // SyntaxRewriter in debug builds. - - """, - clauses: IfConfigClauseListSyntax { - IfConfigClauseSyntax( - poundKeyword: .poundIfToken(), - condition: ExprSyntax("DEBUG"), - elements: .statements( - try CodeBlockItemListSyntax { - try FunctionDeclSyntax( - """ - /// Implementation detail of visit(_:). Do not call directly. - /// - /// Returns the function that shall be called to visit a specific syntax node. - /// - /// To determine the correct specific visitation function for a syntax node, - /// we need to switch through a huge switch statement that covers all syntax - /// types. In debug builds, the cases of this switch statement do not share - /// stack space (rdar://55929175). Because of this, the switch statement - /// requires about 15KB of stack space. In scenarios with reduced - /// stack size (in particular dispatch queues), this often results in a stack - /// overflow during syntax tree rewriting. - /// - /// To circumvent this problem, make calling the specific visitation function - /// a two-step process: First determine the function to call in this function - /// and return a reference to it, then call it. This way, the stack frame - /// that determines the correct visitation function will be popped of the - /// stack before the function is being called, making the switch's stack - /// space transient instead of having it linger in the call stack. - private func visitationFunc(for node: Syntax) -> ((inout Syntax) -> Void) - """ - ) { - try SwitchExprSyntax("switch node.raw.kind") { - SwitchCaseSyntax("case .token:") { - StmtSyntax("return { self.visitImpl(&$0, TokenSyntax.self, self.visit) }") - } - - for node in NON_BASE_SYNTAX_NODES { - SwitchCaseSyntax("case .\(node.varOrCaseName):") { - StmtSyntax("return { self.visitImpl(&$0, \(node.kind.syntaxType).self, self.visit) }") - } - } - } - } - - DeclSyntax( - """ - private func dispatchVisit(_ node: inout Syntax) { - visitationFunc(for: node)(&node) - } - """ - ) - } - ) - ) - IfConfigClauseSyntax( - poundKeyword: .poundElseToken(), - elements: .statements( - CodeBlockItemListSyntax { - try! FunctionDeclSyntax("private func dispatchVisit(_ node: inout Syntax)") { - try SwitchExprSyntax("switch node.raw.kind") { - SwitchCaseSyntax("case .token:") { - StmtSyntax("return visitImpl(&node, TokenSyntax.self, visit)") - } - - for node in NON_BASE_SYNTAX_NODES { - SwitchCaseSyntax("case .\(node.varOrCaseName):") { - StmtSyntax("return visitImpl(&node, \(node.kind.syntaxType).self, visit)") - } - } - } - } - } - ) - ) - } - ) - - DeclSyntax( - """ - private func visitChildren(_ node: Syntax) -> Syntax { - // Walk over all children of this node and rewrite them. Don't store any - // rewritten nodes until the first non-`nil` value is encountered. When this - // happens, retrieve all previous syntax nodes from the parent node to - // initialize the new layout. Once we know that we have to rewrite the - // layout, we need to collect all further children, regardless of whether - // they are rewritten or not. - - // newLayout is nil until the first child node is rewritten and rewritten - // nodes are being collected. - var newLayout: UnsafeMutableBufferPointer = .init(start: nil, count: 0) - - // Keep 'SyntaxArena' of rewritten nodes alive until they are wrapped - // with 'Syntax' - var rewrittens: ContiguousArray = [] - - for case let (child?, info) in RawSyntaxChildren(node) where viewMode.shouldTraverse(node: child) { - - // Build the Syntax node to rewrite - var childNode = nodeFactory.create(parent: node, raw: child, absoluteInfo: info) - - dispatchVisit(&childNode) - if childNode.raw.id != child.id { - // The node was rewritten, let's handle it - - if newLayout.baseAddress == nil { - // We have not yet collected any previous rewritten nodes. Initialize - // the new layout with the previous nodes of the parent. - newLayout = .allocate(capacity: node.raw.layoutView!.children.count) - _ = newLayout.initialize(fromContentsOf: node.raw.layoutView!.children) - } - - // Update the rewritten child. - newLayout[Int(info.indexInParent)] = childNode.raw - // Retain the syntax arena of the new node until it's wrapped with Syntax node. - rewrittens.append(childNode.raw.arenaReference.retained) - } - - // Recycle 'childNode.info' - nodeFactory.dispose(&childNode) - } - - if newLayout.baseAddress != nil { - // A child node was rewritten. Build the updated node. - - let arena = self.arena ?? SyntaxArena() - let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: arena) - newLayout.deinitialize() - newLayout.deallocate() - // 'withExtendedLifetime' to keep 'SyntaxArena's of them alive until here. - return withExtendedLifetime(rewrittens) { - Syntax(raw: newRaw, rawNodeArena: arena) - } - } else { - // No child node was rewritten. So no need to change this node as well. - return node - } - } - """ - ) - } -} diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewritersFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewritersFile.swift new file mode 100644 index 00000000000..734a37f5546 --- /dev/null +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxRewritersFile.swift @@ -0,0 +1,401 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax +import SwiftSyntaxBuilder +import SyntaxSupport +import Utils + +func syntaxRewriterFile( + className: String = "SyntaxRewriter", + functionEffectSpecifiers: String = .init(), + functionCallOperators: String = .init() +) -> SourceFileSyntax { + let functionEffectSpecifiers = + if functionEffectSpecifiers.isEmpty { + functionEffectSpecifiers + } else { + " ".appending(functionEffectSpecifiers) + } + let functionCallOperators = + if functionCallOperators.isEmpty { + functionCallOperators + } else { + functionCallOperators.appending(" ") + } + + return SourceFileSyntax(leadingTrivia: copyrightHeader) { + try! ClassDeclSyntax( + """ + // + // This file defines the \(raw: className), a class that performs a standard walk + // and tree-rebuilding pattern. + // + // Subclassers of this class can override the walking behavior for any syntax + // node and transform nodes however they like. + // + //===----------------------------------------------------------------------===// + + open class \(raw: className) + """ + ) { + DeclSyntax("public let viewMode: SyntaxTreeViewMode") + DeclSyntax( + """ + /// The arena in which the parents of rewritten nodes should be allocated. + /// + /// The `\(raw: className)` subclass is responsible for generating the rewritten nodes. To incorporate them into the + /// tree, all of the rewritten node's parents also need to be re-created. This is the arena in which those + /// intermediate nodes should be allocated. + private let arena: SyntaxArena? + """ + ) + + DeclSyntax( + """ + /// 'Syntax' object factory recycling 'Syntax.Info' instances. + private let nodeFactory: SyntaxNodeFactory = SyntaxNodeFactory() + """ + ) + + DeclSyntax( + """ + public init(viewMode: SyntaxTreeViewMode = .sourceAccurate) { + self.viewMode = viewMode + self.arena = nil + } + """ + ) + + DeclSyntax( + """ + @_spi(RawSyntax) + public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, arena: SyntaxArena? = nil) { + self.viewMode = viewMode + self.arena = arena + } + """ + ) + + DeclSyntax( + """ + /// Rewrite `node`, keeping its parent unless `detach` is `true`. + public func rewrite(_ node: some SyntaxProtocol, detach: Bool = false)\(raw: functionEffectSpecifiers) -> Syntax { + var rewritten = Syntax(node) + \(raw: functionCallOperators)self.dispatchVisit(&rewritten) + if detach { + return rewritten + } + + return withExtendedLifetime(rewritten) { + return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, allocationArena: SyntaxArena()) + } + } + """ + ) + + DeclSyntax( + """ + /// Visit a ``TokenSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ token: TokenSyntax)\(raw: functionEffectSpecifiers) -> TokenSyntax { + return token + } + """ + ) + + DeclSyntax( + """ + /// The function called before visiting the node and its descendants. + /// - node: the node we are about to visit. + open func visitPre(_ node: Syntax)\(raw: functionEffectSpecifiers) {} + """ + ) + + DeclSyntax( + """ + /// Override point to choose custom visitation dispatch instead of the + /// specialized `visit(_:)` methods. Use this instead of those methods if + /// you intend to dynamically dispatch rewriting behavior. + /// - note: If this method returns a non-nil result, the subsequent + /// `visitAny(_:)` methods and the specialized `visit(_:)` + /// methods will not be called for this node and the + /// visited node will be replaced by the returned node in the + /// rewritten tree. + /// You can call the ``\(raw: className)/rewrite(_:detach:)`` + /// method recursively when returning a non-nil result + /// if you want to visit the node's children anyway. + open func visitAny(_ node: Syntax)\(raw: functionEffectSpecifiers) -> Syntax? { + return nil + } + """ + ) + + DeclSyntax( + """ + /// The function called after visiting the node and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: Syntax)\(raw: functionEffectSpecifiers) {} + """ + ) + + DeclSyntax( + """ + /// Visit any Syntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + @available(*, deprecated, renamed: "rewrite(_:detach:)") + public func visit(_ node: Syntax)\(raw: functionEffectSpecifiers) -> Syntax { + var rewritten = node + \(raw: functionCallOperators)dispatchVisit(&rewritten) + return rewritten + } + """ + ) + + DeclSyntax( + """ + public func visit(_ node: T)\(raw: functionEffectSpecifiers) -> T { + var rewritten = Syntax(node) + \(raw: functionCallOperators)dispatchVisit(&rewritten) + return rewritten.cast(T.self) + } + """ + ) + + for node in SYNTAX_NODES where !node.kind.isBase { + if (node.base == .syntax || node.base == .syntaxCollection) && node.kind != .missing { + DeclSyntax( + """ + /// Visit a \(raw: node.kind.doccLink). + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + \(node.apiAttributes())\ + open func visit(_ node: \(node.kind.syntaxType))\(raw: functionEffectSpecifiers) -> \(node.kind.syntaxType) { + return \(raw: functionCallOperators)visitChildren(node._syntaxNode).cast(\(node.kind.syntaxType).self) + } + """ + ) + } else { + DeclSyntax( + """ + /// Visit a \(raw: node.kind.doccLink). + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + \(node.apiAttributes())\ + open func visit(_ node: \(node.kind.syntaxType))\(raw: functionEffectSpecifiers) -> \(node.baseType.syntaxBaseName) { + return \(node.baseType.syntaxBaseName)(\(raw: functionCallOperators)visitChildren(node._syntaxNode).cast(\(node.kind.syntaxType).self)) + } + """ + ) + } + } + + for baseNode in SYNTAX_NODES + where baseNode.kind.isBase && baseNode.kind != .syntax && baseNode.kind != .syntaxCollection { + let baseKind = baseNode.kind + DeclSyntax( + """ + /// Visit any \(baseKind.syntaxType) node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + \(baseNode.apiAttributes())\ + public func visit(_ node: \(baseKind.syntaxType))\(raw: functionEffectSpecifiers) -> \(baseKind.syntaxType) { + var node: Syntax = Syntax(node) + \(raw: functionCallOperators)dispatchVisit(&node) + return node.cast(\(baseKind.syntaxType).self) + } + """ + ) + } + + DeclSyntax( + """ + /// Interpret `node` as a node of type `nodeType`, visit it, calling + /// the `visit` to transform the node. + @inline(__always) + private func visitImpl( + _ node: inout Syntax, + _ nodeType: NodeType.Type, + _ visit: (NodeType)\(raw: functionEffectSpecifiers) -> some SyntaxProtocol + )\(raw: functionEffectSpecifiers) { + let origNode = node + \(raw: functionCallOperators)visitPre(origNode) + node = if let newNode = \(raw: functionCallOperators)visitAny(origNode) { + newNode + } else { + \(raw: functionCallOperators)Syntax(visit(origNode.cast(NodeType.self))) + } + \(raw: functionCallOperators)visitPost(origNode) + } + """ + ) + + try IfConfigDeclSyntax( + leadingTrivia: + """ + // SwiftSyntax requires a lot of stack space in debug builds for syntax tree + // rewriting. In scenarios with reduced stack space (in particular dispatch + // queues), this easily results in a stack overflow. To work around this issue, + // use a less performant but also less stack-hungry version of SwiftSyntax's + // \(className) in debug builds. + + """, + clauses: IfConfigClauseListSyntax { + IfConfigClauseSyntax( + poundKeyword: .poundIfToken(), + condition: ExprSyntax("DEBUG"), + elements: .statements( + try CodeBlockItemListSyntax { + try FunctionDeclSyntax( + """ + /// Implementation detail of visit(_:). Do not call directly. + /// + /// Returns the function that shall be called to visit a specific syntax node. + /// + /// To determine the correct specific visitation function for a syntax node, + /// we need to switch through a huge switch statement that covers all syntax + /// types. In debug builds, the cases of this switch statement do not share + /// stack space (rdar://55929175). Because of this, the switch statement + /// requires about 15KB of stack space. In scenarios with reduced + /// stack size (in particular dispatch queues), this often results in a stack + /// overflow during syntax tree rewriting. + /// + /// To circumvent this problem, make calling the specific visitation function + /// a two-step process: First determine the function to call in this function + /// and return a reference to it, then call it. This way, the stack frame + /// that determines the correct visitation function will be popped of the + /// stack before the function is being called, making the switch's stack + /// space transient instead of having it linger in the call stack. + private func visitationFunc(for node: Syntax)\(raw: functionEffectSpecifiers) -> ((inout Syntax)\(raw: functionEffectSpecifiers) -> Void) + """ + ) { + try SwitchExprSyntax("switch node.raw.kind") { + SwitchCaseSyntax("case .token:") { + StmtSyntax( + "return { \(raw: functionCallOperators)self.visitImpl(&$0, TokenSyntax.self, self.visit) }" + ) + } + + for node in NON_BASE_SYNTAX_NODES { + SwitchCaseSyntax("case .\(node.varOrCaseName):") { + StmtSyntax( + "return { \(raw: functionCallOperators)self.visitImpl(&$0, \(node.kind.syntaxType).self, self.visit) }" + ) + } + } + } + } + + DeclSyntax( + """ + private func dispatchVisit(_ node: inout Syntax)\(raw: functionEffectSpecifiers) { + \(raw: functionCallOperators)visitationFunc(for: node)(&node) + } + """ + ) + } + ) + ) + IfConfigClauseSyntax( + poundKeyword: .poundElseToken(), + elements: .statements( + CodeBlockItemListSyntax { + try! FunctionDeclSyntax( + "private func dispatchVisit(_ node: inout Syntax)\(raw: functionEffectSpecifiers)" + ) { + try SwitchExprSyntax("switch node.raw.kind") { + SwitchCaseSyntax("case .token:") { + StmtSyntax("return \(raw: functionCallOperators)visitImpl(&node, TokenSyntax.self, visit)") + } + + for node in NON_BASE_SYNTAX_NODES { + SwitchCaseSyntax("case .\(node.varOrCaseName):") { + StmtSyntax( + "return \(raw: functionCallOperators)visitImpl(&node, \(node.kind.syntaxType).self, visit)" + ) + } + } + } + } + } + ) + ) + } + ) + + DeclSyntax( + """ + private func visitChildren(_ node: Syntax)\(raw: functionEffectSpecifiers) -> Syntax { + // Walk over all children of this node and rewrite them. Don't store any + // rewritten nodes until the first non-`nil` value is encountered. When this + // happens, retrieve all previous syntax nodes from the parent node to + // initialize the new layout. Once we know that we have to rewrite the + // layout, we need to collect all further children, regardless of whether + // they are rewritten or not. + + // newLayout is nil until the first child node is rewritten and rewritten + // nodes are being collected. + var newLayout: UnsafeMutableBufferPointer = .init(start: nil, count: 0) + + // Keep 'SyntaxArena' of rewritten nodes alive until they are wrapped + // with 'Syntax' + var rewrittens: ContiguousArray = [] + + for case let (child?, info) in RawSyntaxChildren(node) where viewMode.shouldTraverse(node: child) { + + // Build the Syntax node to rewrite + var childNode = nodeFactory.create(parent: node, raw: child, absoluteInfo: info) + + \(raw: functionCallOperators)dispatchVisit(&childNode) + if childNode.raw.id != child.id { + // The node was rewritten, let's handle it + + if newLayout.baseAddress == nil { + // We have not yet collected any previous rewritten nodes. Initialize + // the new layout with the previous nodes of the parent. + newLayout = .allocate(capacity: node.raw.layoutView!.children.count) + _ = newLayout.initialize(fromContentsOf: node.raw.layoutView!.children) + } + + // Update the rewritten child. + newLayout[Int(info.indexInParent)] = childNode.raw + // Retain the syntax arena of the new node until it's wrapped with Syntax node. + rewrittens.append(childNode.raw.arenaReference.retained) + } + + // Recycle 'childNode.info' + nodeFactory.dispose(&childNode) + } + + if newLayout.baseAddress != nil { + // A child node was rewritten. Build the updated node. + + let arena = self.arena ?? SyntaxArena() + let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: arena) + newLayout.deinitialize() + newLayout.deallocate() + // 'withExtendedLifetime' to keep 'SyntaxArena's of them alive until here. + return withExtendedLifetime(rewrittens) { + Syntax(raw: newRaw, rawNodeArena: arena) + } + } else { + // No child node was rewritten. So no need to change this node as well. + return node + } + } + """ + ) + } + } +} diff --git a/Sources/SwiftSyntax/CMakeLists.txt b/Sources/SwiftSyntax/CMakeLists.txt index 617183bab6f..1ee5b48c06d 100644 --- a/Sources/SwiftSyntax/CMakeLists.txt +++ b/Sources/SwiftSyntax/CMakeLists.txt @@ -57,6 +57,7 @@ add_swift_syntax_library(SwiftSyntax generated/raw/RawSyntaxNodesTUVWXYZ.swift generated/raw/RawSyntaxValidation.swift + generated/AsyncSyntaxRewriter.swift generated/ChildNameForKeyPath.swift generated/Keyword.swift generated/RenamedChildrenCompatibility.swift diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md index 08529853263..4979721d061 100644 --- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md +++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md @@ -57,6 +57,7 @@ These articles are intended for developers wishing to contribute to SwiftSyntax - - - +- - - - diff --git a/Sources/SwiftSyntax/generated/AsyncSyntaxRewriter.swift b/Sources/SwiftSyntax/generated/AsyncSyntaxRewriter.swift new file mode 100644 index 00000000000..eb0048e3e33 --- /dev/null +++ b/Sources/SwiftSyntax/generated/AsyncSyntaxRewriter.swift @@ -0,0 +1,3968 @@ +//// Automatically generated by generate-swift-syntax +//// Do not edit directly! +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +// +// This file defines the AsyncSyntaxRewriter, a class that performs a standard walk +// and tree-rebuilding pattern. +// +// Subclassers of this class can override the walking behavior for any syntax +// node and transform nodes however they like. +// +//===----------------------------------------------------------------------===// + +open class AsyncSyntaxRewriter { + public let viewMode: SyntaxTreeViewMode + + /// The arena in which the parents of rewritten nodes should be allocated. + /// + /// The `AsyncSyntaxRewriter` subclass is responsible for generating the rewritten nodes. To incorporate them into the + /// tree, all of the rewritten node's parents also need to be re-created. This is the arena in which those + /// intermediate nodes should be allocated. + private let arena: SyntaxArena? + + /// 'Syntax' object factory recycling 'Syntax.Info' instances. + private let nodeFactory: SyntaxNodeFactory = SyntaxNodeFactory() + + public init(viewMode: SyntaxTreeViewMode = .sourceAccurate) { + self.viewMode = viewMode + self.arena = nil + } + + @_spi(RawSyntax) + public init(viewMode: SyntaxTreeViewMode = .sourceAccurate, arena: SyntaxArena? = nil) { + self.viewMode = viewMode + self.arena = arena + } + + /// Rewrite `node`, keeping its parent unless `detach` is `true`. + public func rewrite(_ node: some SyntaxProtocol, detach: Bool = false) async -> Syntax { + var rewritten = Syntax(node) + await self.dispatchVisit(&rewritten) + if detach { + return rewritten + } + + return withExtendedLifetime(rewritten) { + return Syntax(node).replacingSelf(rewritten.raw, rawNodeArena: rewritten.raw.arenaReference.retained, allocationArena: SyntaxArena()) + } + } + + /// Visit a ``TokenSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ token: TokenSyntax) async -> TokenSyntax { + return token + } + + /// The function called before visiting the node and its descendants. + /// - node: the node we are about to visit. + open func visitPre(_ node: Syntax) async { + } + + /// Override point to choose custom visitation dispatch instead of the + /// specialized `visit(_:)` methods. Use this instead of those methods if + /// you intend to dynamically dispatch rewriting behavior. + /// - note: If this method returns a non-nil result, the subsequent + /// `visitAny(_:)` methods and the specialized `visit(_:)` + /// methods will not be called for this node and the + /// visited node will be replaced by the returned node in the + /// rewritten tree. + /// You can call the ``AsyncSyntaxRewriter/rewrite(_:detach:)`` + /// method recursively when returning a non-nil result + /// if you want to visit the node's children anyway. + open func visitAny(_ node: Syntax) async -> Syntax? { + return nil + } + + /// The function called after visiting the node and its descendants. + /// - node: the node we just finished visiting. + open func visitPost(_ node: Syntax) async { + } + + /// Visit any Syntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + @available(*, deprecated, renamed: "rewrite(_:detach:)") + public func visit(_ node: Syntax) async -> Syntax { + var rewritten = node + await dispatchVisit(&rewritten) + return rewritten + } + + public func visit(_ node: T) async -> T { + var rewritten = Syntax(node) + await dispatchVisit(&rewritten) + return rewritten.cast(T.self) + } + + /// Visit a ``AccessorBlockSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessorBlockSyntax) async -> AccessorBlockSyntax { + return await visitChildren(node._syntaxNode).cast(AccessorBlockSyntax.self) + } + + /// Visit a ``AccessorDeclListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessorDeclListSyntax) async -> AccessorDeclListSyntax { + return await visitChildren(node._syntaxNode).cast(AccessorDeclListSyntax.self) + } + + /// Visit a ``AccessorDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessorDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(AccessorDeclSyntax.self)) + } + + /// Visit a ``AccessorEffectSpecifiersSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessorEffectSpecifiersSyntax) async -> AccessorEffectSpecifiersSyntax { + return await visitChildren(node._syntaxNode).cast(AccessorEffectSpecifiersSyntax.self) + } + + /// Visit a ``AccessorParametersSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AccessorParametersSyntax) async -> AccessorParametersSyntax { + return await visitChildren(node._syntaxNode).cast(AccessorParametersSyntax.self) + } + + /// Visit a ``ActorDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ActorDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(ActorDeclSyntax.self)) + } + + /// Visit a ``ArrayElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ArrayElementListSyntax) async -> ArrayElementListSyntax { + return await visitChildren(node._syntaxNode).cast(ArrayElementListSyntax.self) + } + + /// Visit a ``ArrayElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ArrayElementSyntax) async -> ArrayElementSyntax { + return await visitChildren(node._syntaxNode).cast(ArrayElementSyntax.self) + } + + /// Visit a ``ArrayExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ArrayExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(ArrayExprSyntax.self)) + } + + /// Visit a ``ArrayTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ArrayTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(ArrayTypeSyntax.self)) + } + + /// Visit a ``ArrowExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ArrowExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(ArrowExprSyntax.self)) + } + + /// Visit a ``AsExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AsExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(AsExprSyntax.self)) + } + + /// Visit a ``AssignmentExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AssignmentExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(AssignmentExprSyntax.self)) + } + + /// Visit a ``AssociatedTypeDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AssociatedTypeDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(AssociatedTypeDeclSyntax.self)) + } + + /// Visit a ``AttributeListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AttributeListSyntax) async -> AttributeListSyntax { + return await visitChildren(node._syntaxNode).cast(AttributeListSyntax.self) + } + + /// Visit a ``AttributeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AttributeSyntax) async -> AttributeSyntax { + return await visitChildren(node._syntaxNode).cast(AttributeSyntax.self) + } + + /// Visit a ``AttributedTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AttributedTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(AttributedTypeSyntax.self)) + } + + /// Visit a ``AvailabilityArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AvailabilityArgumentListSyntax) async -> AvailabilityArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(AvailabilityArgumentListSyntax.self) + } + + /// Visit a ``AvailabilityArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AvailabilityArgumentSyntax) async -> AvailabilityArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(AvailabilityArgumentSyntax.self) + } + + /// Visit a ``AvailabilityConditionSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AvailabilityConditionSyntax) async -> AvailabilityConditionSyntax { + return await visitChildren(node._syntaxNode).cast(AvailabilityConditionSyntax.self) + } + + /// Visit a ``AvailabilityLabeledArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AvailabilityLabeledArgumentSyntax) async -> AvailabilityLabeledArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(AvailabilityLabeledArgumentSyntax.self) + } + + /// Visit a ``AwaitExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: AwaitExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(AwaitExprSyntax.self)) + } + + /// Visit a ``BackDeployedAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: BackDeployedAttributeArgumentsSyntax) async -> BackDeployedAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(BackDeployedAttributeArgumentsSyntax.self) + } + + /// Visit a ``BinaryOperatorExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: BinaryOperatorExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(BinaryOperatorExprSyntax.self)) + } + + /// Visit a ``BooleanLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: BooleanLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(BooleanLiteralExprSyntax.self)) + } + + /// Visit a ``BorrowExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: BorrowExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(BorrowExprSyntax.self)) + } + + /// Visit a ``BreakStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: BreakStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(BreakStmtSyntax.self)) + } + + /// Visit a `_CanImportExprSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: _CanImportExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(_CanImportExprSyntax.self)) + } + + /// Visit a `_CanImportVersionInfoSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: _CanImportVersionInfoSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(_CanImportVersionInfoSyntax.self)) + } + + /// Visit a ``CatchClauseListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CatchClauseListSyntax) async -> CatchClauseListSyntax { + return await visitChildren(node._syntaxNode).cast(CatchClauseListSyntax.self) + } + + /// Visit a ``CatchClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CatchClauseSyntax) async -> CatchClauseSyntax { + return await visitChildren(node._syntaxNode).cast(CatchClauseSyntax.self) + } + + /// Visit a ``CatchItemListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CatchItemListSyntax) async -> CatchItemListSyntax { + return await visitChildren(node._syntaxNode).cast(CatchItemListSyntax.self) + } + + /// Visit a ``CatchItemSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CatchItemSyntax) async -> CatchItemSyntax { + return await visitChildren(node._syntaxNode).cast(CatchItemSyntax.self) + } + + /// Visit a ``ClassDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClassDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(ClassDeclSyntax.self)) + } + + /// Visit a ``ClassRestrictionTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClassRestrictionTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(ClassRestrictionTypeSyntax.self)) + } + + /// Visit a ``ClosureCaptureClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureCaptureClauseSyntax) async -> ClosureCaptureClauseSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureCaptureClauseSyntax.self) + } + + /// Visit a ``ClosureCaptureListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureCaptureListSyntax) async -> ClosureCaptureListSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureCaptureListSyntax.self) + } + + /// Visit a ``ClosureCaptureSpecifierSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureCaptureSpecifierSyntax) async -> ClosureCaptureSpecifierSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureCaptureSpecifierSyntax.self) + } + + /// Visit a ``ClosureCaptureSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureCaptureSyntax) async -> ClosureCaptureSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureCaptureSyntax.self) + } + + /// Visit a ``ClosureExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(ClosureExprSyntax.self)) + } + + /// Visit a ``ClosureParameterClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureParameterClauseSyntax) async -> ClosureParameterClauseSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureParameterClauseSyntax.self) + } + + /// Visit a ``ClosureParameterListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureParameterListSyntax) async -> ClosureParameterListSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureParameterListSyntax.self) + } + + /// Visit a ``ClosureParameterSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureParameterSyntax) async -> ClosureParameterSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureParameterSyntax.self) + } + + /// Visit a ``ClosureShorthandParameterListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureShorthandParameterListSyntax) async -> ClosureShorthandParameterListSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureShorthandParameterListSyntax.self) + } + + /// Visit a ``ClosureShorthandParameterSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureShorthandParameterSyntax) async -> ClosureShorthandParameterSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureShorthandParameterSyntax.self) + } + + /// Visit a ``ClosureSignatureSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ClosureSignatureSyntax) async -> ClosureSignatureSyntax { + return await visitChildren(node._syntaxNode).cast(ClosureSignatureSyntax.self) + } + + /// Visit a ``CodeBlockItemListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CodeBlockItemListSyntax) async -> CodeBlockItemListSyntax { + return await visitChildren(node._syntaxNode).cast(CodeBlockItemListSyntax.self) + } + + /// Visit a ``CodeBlockItemSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CodeBlockItemSyntax) async -> CodeBlockItemSyntax { + return await visitChildren(node._syntaxNode).cast(CodeBlockItemSyntax.self) + } + + /// Visit a ``CodeBlockSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CodeBlockSyntax) async -> CodeBlockSyntax { + return await visitChildren(node._syntaxNode).cast(CodeBlockSyntax.self) + } + + /// Visit a ``CompositionTypeElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CompositionTypeElementListSyntax) async -> CompositionTypeElementListSyntax { + return await visitChildren(node._syntaxNode).cast(CompositionTypeElementListSyntax.self) + } + + /// Visit a ``CompositionTypeElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CompositionTypeElementSyntax) async -> CompositionTypeElementSyntax { + return await visitChildren(node._syntaxNode).cast(CompositionTypeElementSyntax.self) + } + + /// Visit a ``CompositionTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CompositionTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(CompositionTypeSyntax.self)) + } + + /// Visit a ``ConditionElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ConditionElementListSyntax) async -> ConditionElementListSyntax { + return await visitChildren(node._syntaxNode).cast(ConditionElementListSyntax.self) + } + + /// Visit a ``ConditionElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ConditionElementSyntax) async -> ConditionElementSyntax { + return await visitChildren(node._syntaxNode).cast(ConditionElementSyntax.self) + } + + /// Visit a ``ConformanceRequirementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ConformanceRequirementSyntax) async -> ConformanceRequirementSyntax { + return await visitChildren(node._syntaxNode).cast(ConformanceRequirementSyntax.self) + } + + /// Visit a ``ConsumeExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ConsumeExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(ConsumeExprSyntax.self)) + } + + /// Visit a ``ContinueStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ContinueStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(ContinueStmtSyntax.self)) + } + + /// Visit a ``ConventionAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ConventionAttributeArgumentsSyntax) async -> ConventionAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(ConventionAttributeArgumentsSyntax.self) + } + + /// Visit a ``ConventionWitnessMethodAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ConventionWitnessMethodAttributeArgumentsSyntax) async -> ConventionWitnessMethodAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(ConventionWitnessMethodAttributeArgumentsSyntax.self) + } + + /// Visit a ``CopyExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: CopyExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(CopyExprSyntax.self)) + } + + /// Visit a ``DeclModifierDetailSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclModifierDetailSyntax) async -> DeclModifierDetailSyntax { + return await visitChildren(node._syntaxNode).cast(DeclModifierDetailSyntax.self) + } + + /// Visit a ``DeclModifierListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclModifierListSyntax) async -> DeclModifierListSyntax { + return await visitChildren(node._syntaxNode).cast(DeclModifierListSyntax.self) + } + + /// Visit a ``DeclModifierSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclModifierSyntax) async -> DeclModifierSyntax { + return await visitChildren(node._syntaxNode).cast(DeclModifierSyntax.self) + } + + /// Visit a ``DeclNameArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclNameArgumentListSyntax) async -> DeclNameArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(DeclNameArgumentListSyntax.self) + } + + /// Visit a ``DeclNameArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclNameArgumentSyntax) async -> DeclNameArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(DeclNameArgumentSyntax.self) + } + + /// Visit a ``DeclNameArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclNameArgumentsSyntax) async -> DeclNameArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(DeclNameArgumentsSyntax.self) + } + + /// Visit a ``DeclReferenceExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeclReferenceExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(DeclReferenceExprSyntax.self)) + } + + /// Visit a ``DeferStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeferStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(DeferStmtSyntax.self)) + } + + /// Visit a ``DeinitializerDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeinitializerDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(DeinitializerDeclSyntax.self)) + } + + /// Visit a ``DeinitializerEffectSpecifiersSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DeinitializerEffectSpecifiersSyntax) async -> DeinitializerEffectSpecifiersSyntax { + return await visitChildren(node._syntaxNode).cast(DeinitializerEffectSpecifiersSyntax.self) + } + + /// Visit a ``DerivativeAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DerivativeAttributeArgumentsSyntax) async -> DerivativeAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(DerivativeAttributeArgumentsSyntax.self) + } + + /// Visit a ``DesignatedTypeListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DesignatedTypeListSyntax) async -> DesignatedTypeListSyntax { + return await visitChildren(node._syntaxNode).cast(DesignatedTypeListSyntax.self) + } + + /// Visit a ``DesignatedTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DesignatedTypeSyntax) async -> DesignatedTypeSyntax { + return await visitChildren(node._syntaxNode).cast(DesignatedTypeSyntax.self) + } + + /// Visit a ``DictionaryElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DictionaryElementListSyntax) async -> DictionaryElementListSyntax { + return await visitChildren(node._syntaxNode).cast(DictionaryElementListSyntax.self) + } + + /// Visit a ``DictionaryElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DictionaryElementSyntax) async -> DictionaryElementSyntax { + return await visitChildren(node._syntaxNode).cast(DictionaryElementSyntax.self) + } + + /// Visit a ``DictionaryExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DictionaryExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(DictionaryExprSyntax.self)) + } + + /// Visit a ``DictionaryTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DictionaryTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(DictionaryTypeSyntax.self)) + } + + /// Visit a ``DifferentiabilityArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DifferentiabilityArgumentListSyntax) async -> DifferentiabilityArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(DifferentiabilityArgumentListSyntax.self) + } + + /// Visit a ``DifferentiabilityArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DifferentiabilityArgumentSyntax) async -> DifferentiabilityArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(DifferentiabilityArgumentSyntax.self) + } + + /// Visit a ``DifferentiabilityArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DifferentiabilityArgumentsSyntax) async -> DifferentiabilityArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(DifferentiabilityArgumentsSyntax.self) + } + + /// Visit a ``DifferentiabilityWithRespectToArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DifferentiabilityWithRespectToArgumentSyntax) async -> DifferentiabilityWithRespectToArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(DifferentiabilityWithRespectToArgumentSyntax.self) + } + + /// Visit a ``DifferentiableAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DifferentiableAttributeArgumentsSyntax) async -> DifferentiableAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(DifferentiableAttributeArgumentsSyntax.self) + } + + /// Visit a ``DiscardAssignmentExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DiscardAssignmentExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(DiscardAssignmentExprSyntax.self)) + } + + /// Visit a ``DiscardStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DiscardStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(DiscardStmtSyntax.self)) + } + + /// Visit a `DoExprSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: DoExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(DoExprSyntax.self)) + } + + /// Visit a ``DoStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DoStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(DoStmtSyntax.self)) + } + + /// Visit a ``DocumentationAttributeArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DocumentationAttributeArgumentListSyntax) async -> DocumentationAttributeArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(DocumentationAttributeArgumentListSyntax.self) + } + + /// Visit a ``DocumentationAttributeArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DocumentationAttributeArgumentSyntax) async -> DocumentationAttributeArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(DocumentationAttributeArgumentSyntax.self) + } + + /// Visit a ``DynamicReplacementAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: DynamicReplacementAttributeArgumentsSyntax) async -> DynamicReplacementAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(DynamicReplacementAttributeArgumentsSyntax.self) + } + + /// Visit a ``EditorPlaceholderDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EditorPlaceholderDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(EditorPlaceholderDeclSyntax.self)) + } + + /// Visit a ``EditorPlaceholderExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EditorPlaceholderExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(EditorPlaceholderExprSyntax.self)) + } + + /// Visit a ``EffectsAttributeArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EffectsAttributeArgumentListSyntax) async -> EffectsAttributeArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(EffectsAttributeArgumentListSyntax.self) + } + + /// Visit a ``EnumCaseDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(EnumCaseDeclSyntax.self)) + } + + /// Visit a ``EnumCaseElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseElementListSyntax) async -> EnumCaseElementListSyntax { + return await visitChildren(node._syntaxNode).cast(EnumCaseElementListSyntax.self) + } + + /// Visit a ``EnumCaseElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseElementSyntax) async -> EnumCaseElementSyntax { + return await visitChildren(node._syntaxNode).cast(EnumCaseElementSyntax.self) + } + + /// Visit a ``EnumCaseParameterClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseParameterClauseSyntax) async -> EnumCaseParameterClauseSyntax { + return await visitChildren(node._syntaxNode).cast(EnumCaseParameterClauseSyntax.self) + } + + /// Visit a ``EnumCaseParameterListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseParameterListSyntax) async -> EnumCaseParameterListSyntax { + return await visitChildren(node._syntaxNode).cast(EnumCaseParameterListSyntax.self) + } + + /// Visit a ``EnumCaseParameterSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumCaseParameterSyntax) async -> EnumCaseParameterSyntax { + return await visitChildren(node._syntaxNode).cast(EnumCaseParameterSyntax.self) + } + + /// Visit a ``EnumDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: EnumDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(EnumDeclSyntax.self)) + } + + /// Visit a ``ExposeAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExposeAttributeArgumentsSyntax) async -> ExposeAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(ExposeAttributeArgumentsSyntax.self) + } + + /// Visit a ``ExprListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExprListSyntax) async -> ExprListSyntax { + return await visitChildren(node._syntaxNode).cast(ExprListSyntax.self) + } + + /// Visit a ``ExpressionPatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExpressionPatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(ExpressionPatternSyntax.self)) + } + + /// Visit a ``ExpressionSegmentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExpressionSegmentSyntax) async -> ExpressionSegmentSyntax { + return await visitChildren(node._syntaxNode).cast(ExpressionSegmentSyntax.self) + } + + /// Visit a ``ExpressionStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExpressionStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(ExpressionStmtSyntax.self)) + } + + /// Visit a ``ExtensionDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ExtensionDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(ExtensionDeclSyntax.self)) + } + + /// Visit a ``FallThroughStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FallThroughStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(FallThroughStmtSyntax.self)) + } + + /// Visit a ``FloatLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FloatLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(FloatLiteralExprSyntax.self)) + } + + /// Visit a ``ForStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ForStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(ForStmtSyntax.self)) + } + + /// Visit a ``ForceUnwrapExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ForceUnwrapExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(ForceUnwrapExprSyntax.self)) + } + + /// Visit a ``FunctionCallExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionCallExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(FunctionCallExprSyntax.self)) + } + + /// Visit a ``FunctionDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(FunctionDeclSyntax.self)) + } + + /// Visit a ``FunctionEffectSpecifiersSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionEffectSpecifiersSyntax) async -> FunctionEffectSpecifiersSyntax { + return await visitChildren(node._syntaxNode).cast(FunctionEffectSpecifiersSyntax.self) + } + + /// Visit a ``FunctionParameterClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionParameterClauseSyntax) async -> FunctionParameterClauseSyntax { + return await visitChildren(node._syntaxNode).cast(FunctionParameterClauseSyntax.self) + } + + /// Visit a ``FunctionParameterListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionParameterListSyntax) async -> FunctionParameterListSyntax { + return await visitChildren(node._syntaxNode).cast(FunctionParameterListSyntax.self) + } + + /// Visit a ``FunctionParameterSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionParameterSyntax) async -> FunctionParameterSyntax { + return await visitChildren(node._syntaxNode).cast(FunctionParameterSyntax.self) + } + + /// Visit a ``FunctionSignatureSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionSignatureSyntax) async -> FunctionSignatureSyntax { + return await visitChildren(node._syntaxNode).cast(FunctionSignatureSyntax.self) + } + + /// Visit a ``FunctionTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: FunctionTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(FunctionTypeSyntax.self)) + } + + /// Visit a ``GenericArgumentClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericArgumentClauseSyntax) async -> GenericArgumentClauseSyntax { + return await visitChildren(node._syntaxNode).cast(GenericArgumentClauseSyntax.self) + } + + /// Visit a ``GenericArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericArgumentListSyntax) async -> GenericArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(GenericArgumentListSyntax.self) + } + + /// Visit a ``GenericArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericArgumentSyntax) async -> GenericArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(GenericArgumentSyntax.self) + } + + /// Visit a ``GenericParameterClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericParameterClauseSyntax) async -> GenericParameterClauseSyntax { + return await visitChildren(node._syntaxNode).cast(GenericParameterClauseSyntax.self) + } + + /// Visit a ``GenericParameterListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericParameterListSyntax) async -> GenericParameterListSyntax { + return await visitChildren(node._syntaxNode).cast(GenericParameterListSyntax.self) + } + + /// Visit a ``GenericParameterSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericParameterSyntax) async -> GenericParameterSyntax { + return await visitChildren(node._syntaxNode).cast(GenericParameterSyntax.self) + } + + /// Visit a ``GenericRequirementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericRequirementListSyntax) async -> GenericRequirementListSyntax { + return await visitChildren(node._syntaxNode).cast(GenericRequirementListSyntax.self) + } + + /// Visit a ``GenericRequirementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericRequirementSyntax) async -> GenericRequirementSyntax { + return await visitChildren(node._syntaxNode).cast(GenericRequirementSyntax.self) + } + + /// Visit a ``GenericSpecializationExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericSpecializationExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(GenericSpecializationExprSyntax.self)) + } + + /// Visit a ``GenericWhereClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GenericWhereClauseSyntax) async -> GenericWhereClauseSyntax { + return await visitChildren(node._syntaxNode).cast(GenericWhereClauseSyntax.self) + } + + /// Visit a ``GuardStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: GuardStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(GuardStmtSyntax.self)) + } + + /// Visit a ``IdentifierPatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IdentifierPatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(IdentifierPatternSyntax.self)) + } + + /// Visit a ``IdentifierTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IdentifierTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(IdentifierTypeSyntax.self)) + } + + /// Visit a ``IfConfigClauseListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IfConfigClauseListSyntax) async -> IfConfigClauseListSyntax { + return await visitChildren(node._syntaxNode).cast(IfConfigClauseListSyntax.self) + } + + /// Visit a ``IfConfigClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IfConfigClauseSyntax) async -> IfConfigClauseSyntax { + return await visitChildren(node._syntaxNode).cast(IfConfigClauseSyntax.self) + } + + /// Visit a ``IfConfigDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IfConfigDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(IfConfigDeclSyntax.self)) + } + + /// Visit a ``IfExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IfExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(IfExprSyntax.self)) + } + + /// Visit a ``ImplementsAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ImplementsAttributeArgumentsSyntax) async -> ImplementsAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(ImplementsAttributeArgumentsSyntax.self) + } + + /// Visit a ``ImplicitlyUnwrappedOptionalTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(ImplicitlyUnwrappedOptionalTypeSyntax.self)) + } + + /// Visit a ``ImportDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ImportDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(ImportDeclSyntax.self)) + } + + /// Visit a ``ImportPathComponentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ImportPathComponentListSyntax) async -> ImportPathComponentListSyntax { + return await visitChildren(node._syntaxNode).cast(ImportPathComponentListSyntax.self) + } + + /// Visit a ``ImportPathComponentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ImportPathComponentSyntax) async -> ImportPathComponentSyntax { + return await visitChildren(node._syntaxNode).cast(ImportPathComponentSyntax.self) + } + + /// Visit a ``InOutExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InOutExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(InOutExprSyntax.self)) + } + + /// Visit a ``InfixOperatorExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InfixOperatorExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(InfixOperatorExprSyntax.self)) + } + + /// Visit a ``InheritanceClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InheritanceClauseSyntax) async -> InheritanceClauseSyntax { + return await visitChildren(node._syntaxNode).cast(InheritanceClauseSyntax.self) + } + + /// Visit a ``InheritedTypeListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InheritedTypeListSyntax) async -> InheritedTypeListSyntax { + return await visitChildren(node._syntaxNode).cast(InheritedTypeListSyntax.self) + } + + /// Visit a ``InheritedTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InheritedTypeSyntax) async -> InheritedTypeSyntax { + return await visitChildren(node._syntaxNode).cast(InheritedTypeSyntax.self) + } + + /// Visit a ``InitializerClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InitializerClauseSyntax) async -> InitializerClauseSyntax { + return await visitChildren(node._syntaxNode).cast(InitializerClauseSyntax.self) + } + + /// Visit a ``InitializerDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: InitializerDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(InitializerDeclSyntax.self)) + } + + /// Visit a ``IntegerLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IntegerLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(IntegerLiteralExprSyntax.self)) + } + + /// Visit a ``IsExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IsExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(IsExprSyntax.self)) + } + + /// Visit a ``IsTypePatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: IsTypePatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(IsTypePatternSyntax.self)) + } + + /// Visit a ``KeyPathComponentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: KeyPathComponentListSyntax) async -> KeyPathComponentListSyntax { + return await visitChildren(node._syntaxNode).cast(KeyPathComponentListSyntax.self) + } + + /// Visit a ``KeyPathComponentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: KeyPathComponentSyntax) async -> KeyPathComponentSyntax { + return await visitChildren(node._syntaxNode).cast(KeyPathComponentSyntax.self) + } + + /// Visit a ``KeyPathExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: KeyPathExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(KeyPathExprSyntax.self)) + } + + /// Visit a ``KeyPathOptionalComponentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: KeyPathOptionalComponentSyntax) async -> KeyPathOptionalComponentSyntax { + return await visitChildren(node._syntaxNode).cast(KeyPathOptionalComponentSyntax.self) + } + + /// Visit a ``KeyPathPropertyComponentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: KeyPathPropertyComponentSyntax) async -> KeyPathPropertyComponentSyntax { + return await visitChildren(node._syntaxNode).cast(KeyPathPropertyComponentSyntax.self) + } + + /// Visit a ``KeyPathSubscriptComponentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: KeyPathSubscriptComponentSyntax) async -> KeyPathSubscriptComponentSyntax { + return await visitChildren(node._syntaxNode).cast(KeyPathSubscriptComponentSyntax.self) + } + + /// Visit a ``LabeledExprListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: LabeledExprListSyntax) async -> LabeledExprListSyntax { + return await visitChildren(node._syntaxNode).cast(LabeledExprListSyntax.self) + } + + /// Visit a ``LabeledExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: LabeledExprSyntax) async -> LabeledExprSyntax { + return await visitChildren(node._syntaxNode).cast(LabeledExprSyntax.self) + } + + /// Visit a ``LabeledSpecializeArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: LabeledSpecializeArgumentSyntax) async -> LabeledSpecializeArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(LabeledSpecializeArgumentSyntax.self) + } + + /// Visit a ``LabeledStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: LabeledStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(LabeledStmtSyntax.self)) + } + + /// Visit a ``LayoutRequirementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: LayoutRequirementSyntax) async -> LayoutRequirementSyntax { + return await visitChildren(node._syntaxNode).cast(LayoutRequirementSyntax.self) + } + + /// Visit a `LifetimeSpecifierArgumentListSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: LifetimeSpecifierArgumentListSyntax) async -> LifetimeSpecifierArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(LifetimeSpecifierArgumentListSyntax.self) + } + + /// Visit a `LifetimeSpecifierArgumentSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: LifetimeSpecifierArgumentSyntax) async -> LifetimeSpecifierArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(LifetimeSpecifierArgumentSyntax.self) + } + + /// Visit a `LifetimeTypeSpecifierSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: LifetimeTypeSpecifierSyntax) async -> LifetimeTypeSpecifierSyntax { + return await visitChildren(node._syntaxNode).cast(LifetimeTypeSpecifierSyntax.self) + } + + /// Visit a ``MacroDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MacroDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(MacroDeclSyntax.self)) + } + + /// Visit a ``MacroExpansionDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MacroExpansionDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(MacroExpansionDeclSyntax.self)) + } + + /// Visit a ``MacroExpansionExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MacroExpansionExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(MacroExpansionExprSyntax.self)) + } + + /// Visit a ``MatchingPatternConditionSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MatchingPatternConditionSyntax) async -> MatchingPatternConditionSyntax { + return await visitChildren(node._syntaxNode).cast(MatchingPatternConditionSyntax.self) + } + + /// Visit a ``MemberAccessExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MemberAccessExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(MemberAccessExprSyntax.self)) + } + + /// Visit a ``MemberBlockItemListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MemberBlockItemListSyntax) async -> MemberBlockItemListSyntax { + return await visitChildren(node._syntaxNode).cast(MemberBlockItemListSyntax.self) + } + + /// Visit a ``MemberBlockItemSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MemberBlockItemSyntax) async -> MemberBlockItemSyntax { + return await visitChildren(node._syntaxNode).cast(MemberBlockItemSyntax.self) + } + + /// Visit a ``MemberBlockSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MemberBlockSyntax) async -> MemberBlockSyntax { + return await visitChildren(node._syntaxNode).cast(MemberBlockSyntax.self) + } + + /// Visit a ``MemberTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MemberTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(MemberTypeSyntax.self)) + } + + /// Visit a ``MetatypeTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MetatypeTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(MetatypeTypeSyntax.self)) + } + + /// Visit a ``MissingDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(MissingDeclSyntax.self)) + } + + /// Visit a ``MissingExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(MissingExprSyntax.self)) + } + + /// Visit a ``MissingPatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingPatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(MissingPatternSyntax.self)) + } + + /// Visit a ``MissingStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(MissingStmtSyntax.self)) + } + + /// Visit a ``MissingSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingSyntax) async -> Syntax { + return Syntax(await visitChildren(node._syntaxNode).cast(MissingSyntax.self)) + } + + /// Visit a ``MissingTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MissingTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(MissingTypeSyntax.self)) + } + + /// Visit a ``MultipleTrailingClosureElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MultipleTrailingClosureElementListSyntax) async -> MultipleTrailingClosureElementListSyntax { + return await visitChildren(node._syntaxNode).cast(MultipleTrailingClosureElementListSyntax.self) + } + + /// Visit a ``MultipleTrailingClosureElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: MultipleTrailingClosureElementSyntax) async -> MultipleTrailingClosureElementSyntax { + return await visitChildren(node._syntaxNode).cast(MultipleTrailingClosureElementSyntax.self) + } + + /// Visit a ``NamedOpaqueReturnTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: NamedOpaqueReturnTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(NamedOpaqueReturnTypeSyntax.self)) + } + + /// Visit a ``NilLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: NilLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(NilLiteralExprSyntax.self)) + } + + /// Visit a ``ObjCSelectorPieceListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ObjCSelectorPieceListSyntax) async -> ObjCSelectorPieceListSyntax { + return await visitChildren(node._syntaxNode).cast(ObjCSelectorPieceListSyntax.self) + } + + /// Visit a ``ObjCSelectorPieceSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ObjCSelectorPieceSyntax) async -> ObjCSelectorPieceSyntax { + return await visitChildren(node._syntaxNode).cast(ObjCSelectorPieceSyntax.self) + } + + /// Visit a ``OpaqueReturnTypeOfAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OpaqueReturnTypeOfAttributeArgumentsSyntax) async -> OpaqueReturnTypeOfAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(OpaqueReturnTypeOfAttributeArgumentsSyntax.self) + } + + /// Visit a ``OperatorDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OperatorDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(OperatorDeclSyntax.self)) + } + + /// Visit a ``OperatorPrecedenceAndTypesSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OperatorPrecedenceAndTypesSyntax) async -> OperatorPrecedenceAndTypesSyntax { + return await visitChildren(node._syntaxNode).cast(OperatorPrecedenceAndTypesSyntax.self) + } + + /// Visit a ``OptionalBindingConditionSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OptionalBindingConditionSyntax) async -> OptionalBindingConditionSyntax { + return await visitChildren(node._syntaxNode).cast(OptionalBindingConditionSyntax.self) + } + + /// Visit a ``OptionalChainingExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OptionalChainingExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(OptionalChainingExprSyntax.self)) + } + + /// Visit a ``OptionalTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OptionalTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(OptionalTypeSyntax.self)) + } + + /// Visit a ``OriginallyDefinedInAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: OriginallyDefinedInAttributeArgumentsSyntax) async -> OriginallyDefinedInAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(OriginallyDefinedInAttributeArgumentsSyntax.self) + } + + /// Visit a ``PackElementExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PackElementExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(PackElementExprSyntax.self)) + } + + /// Visit a ``PackElementTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PackElementTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(PackElementTypeSyntax.self)) + } + + /// Visit a ``PackExpansionExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PackExpansionExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(PackExpansionExprSyntax.self)) + } + + /// Visit a ``PackExpansionTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PackExpansionTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(PackExpansionTypeSyntax.self)) + } + + /// Visit a ``PatternBindingListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PatternBindingListSyntax) async -> PatternBindingListSyntax { + return await visitChildren(node._syntaxNode).cast(PatternBindingListSyntax.self) + } + + /// Visit a ``PatternBindingSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PatternBindingSyntax) async -> PatternBindingSyntax { + return await visitChildren(node._syntaxNode).cast(PatternBindingSyntax.self) + } + + /// Visit a ``PatternExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PatternExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(PatternExprSyntax.self)) + } + + /// Visit a ``PlatformVersionItemListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PlatformVersionItemListSyntax) async -> PlatformVersionItemListSyntax { + return await visitChildren(node._syntaxNode).cast(PlatformVersionItemListSyntax.self) + } + + /// Visit a ``PlatformVersionItemSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PlatformVersionItemSyntax) async -> PlatformVersionItemSyntax { + return await visitChildren(node._syntaxNode).cast(PlatformVersionItemSyntax.self) + } + + /// Visit a ``PlatformVersionSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PlatformVersionSyntax) async -> PlatformVersionSyntax { + return await visitChildren(node._syntaxNode).cast(PlatformVersionSyntax.self) + } + + /// Visit a ``PostfixIfConfigExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PostfixIfConfigExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(PostfixIfConfigExprSyntax.self)) + } + + /// Visit a ``PostfixOperatorExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PostfixOperatorExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(PostfixOperatorExprSyntax.self)) + } + + /// Visit a ``PoundSourceLocationArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PoundSourceLocationArgumentsSyntax) async -> PoundSourceLocationArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(PoundSourceLocationArgumentsSyntax.self) + } + + /// Visit a ``PoundSourceLocationSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PoundSourceLocationSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(PoundSourceLocationSyntax.self)) + } + + /// Visit a ``PrecedenceGroupAssignmentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupAssignmentSyntax) async -> PrecedenceGroupAssignmentSyntax { + return await visitChildren(node._syntaxNode).cast(PrecedenceGroupAssignmentSyntax.self) + } + + /// Visit a ``PrecedenceGroupAssociativitySyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupAssociativitySyntax) async -> PrecedenceGroupAssociativitySyntax { + return await visitChildren(node._syntaxNode).cast(PrecedenceGroupAssociativitySyntax.self) + } + + /// Visit a ``PrecedenceGroupAttributeListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupAttributeListSyntax) async -> PrecedenceGroupAttributeListSyntax { + return await visitChildren(node._syntaxNode).cast(PrecedenceGroupAttributeListSyntax.self) + } + + /// Visit a ``PrecedenceGroupDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(PrecedenceGroupDeclSyntax.self)) + } + + /// Visit a ``PrecedenceGroupNameListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupNameListSyntax) async -> PrecedenceGroupNameListSyntax { + return await visitChildren(node._syntaxNode).cast(PrecedenceGroupNameListSyntax.self) + } + + /// Visit a ``PrecedenceGroupNameSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupNameSyntax) async -> PrecedenceGroupNameSyntax { + return await visitChildren(node._syntaxNode).cast(PrecedenceGroupNameSyntax.self) + } + + /// Visit a ``PrecedenceGroupRelationSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrecedenceGroupRelationSyntax) async -> PrecedenceGroupRelationSyntax { + return await visitChildren(node._syntaxNode).cast(PrecedenceGroupRelationSyntax.self) + } + + /// Visit a ``PrefixOperatorExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrefixOperatorExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(PrefixOperatorExprSyntax.self)) + } + + /// Visit a ``PrimaryAssociatedTypeClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrimaryAssociatedTypeClauseSyntax) async -> PrimaryAssociatedTypeClauseSyntax { + return await visitChildren(node._syntaxNode).cast(PrimaryAssociatedTypeClauseSyntax.self) + } + + /// Visit a ``PrimaryAssociatedTypeListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrimaryAssociatedTypeListSyntax) async -> PrimaryAssociatedTypeListSyntax { + return await visitChildren(node._syntaxNode).cast(PrimaryAssociatedTypeListSyntax.self) + } + + /// Visit a ``PrimaryAssociatedTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: PrimaryAssociatedTypeSyntax) async -> PrimaryAssociatedTypeSyntax { + return await visitChildren(node._syntaxNode).cast(PrimaryAssociatedTypeSyntax.self) + } + + /// Visit a ``ProtocolDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ProtocolDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(ProtocolDeclSyntax.self)) + } + + /// Visit a ``RegexLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: RegexLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(RegexLiteralExprSyntax.self)) + } + + /// Visit a ``RepeatStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: RepeatStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(RepeatStmtSyntax.self)) + } + + /// Visit a ``ReturnClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ReturnClauseSyntax) async -> ReturnClauseSyntax { + return await visitChildren(node._syntaxNode).cast(ReturnClauseSyntax.self) + } + + /// Visit a ``ReturnStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ReturnStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(ReturnStmtSyntax.self)) + } + + /// Visit a ``SameTypeRequirementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SameTypeRequirementSyntax) async -> SameTypeRequirementSyntax { + return await visitChildren(node._syntaxNode).cast(SameTypeRequirementSyntax.self) + } + + /// Visit a ``SequenceExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SequenceExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(SequenceExprSyntax.self)) + } + + /// Visit a ``SimpleStringLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SimpleStringLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(SimpleStringLiteralExprSyntax.self)) + } + + /// Visit a ``SimpleStringLiteralSegmentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SimpleStringLiteralSegmentListSyntax) async -> SimpleStringLiteralSegmentListSyntax { + return await visitChildren(node._syntaxNode).cast(SimpleStringLiteralSegmentListSyntax.self) + } + + /// Visit a ``SimpleTypeSpecifierSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SimpleTypeSpecifierSyntax) async -> SimpleTypeSpecifierSyntax { + return await visitChildren(node._syntaxNode).cast(SimpleTypeSpecifierSyntax.self) + } + + /// Visit a ``SomeOrAnyTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SomeOrAnyTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(SomeOrAnyTypeSyntax.self)) + } + + /// Visit a ``SourceFileSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SourceFileSyntax) async -> SourceFileSyntax { + return await visitChildren(node._syntaxNode).cast(SourceFileSyntax.self) + } + + /// Visit a ``SpecializeAttributeArgumentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SpecializeAttributeArgumentListSyntax) async -> SpecializeAttributeArgumentListSyntax { + return await visitChildren(node._syntaxNode).cast(SpecializeAttributeArgumentListSyntax.self) + } + + /// Visit a ``SpecializeAvailabilityArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SpecializeAvailabilityArgumentSyntax) async -> SpecializeAvailabilityArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(SpecializeAvailabilityArgumentSyntax.self) + } + + /// Visit a ``SpecializeTargetFunctionArgumentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SpecializeTargetFunctionArgumentSyntax) async -> SpecializeTargetFunctionArgumentSyntax { + return await visitChildren(node._syntaxNode).cast(SpecializeTargetFunctionArgumentSyntax.self) + } + + /// Visit a ``StringLiteralExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: StringLiteralExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(StringLiteralExprSyntax.self)) + } + + /// Visit a ``StringLiteralSegmentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: StringLiteralSegmentListSyntax) async -> StringLiteralSegmentListSyntax { + return await visitChildren(node._syntaxNode).cast(StringLiteralSegmentListSyntax.self) + } + + /// Visit a ``StringSegmentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: StringSegmentSyntax) async -> StringSegmentSyntax { + return await visitChildren(node._syntaxNode).cast(StringSegmentSyntax.self) + } + + /// Visit a ``StructDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: StructDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(StructDeclSyntax.self)) + } + + /// Visit a ``SubscriptCallExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SubscriptCallExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(SubscriptCallExprSyntax.self)) + } + + /// Visit a ``SubscriptDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SubscriptDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(SubscriptDeclSyntax.self)) + } + + /// Visit a ``SuperExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SuperExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(SuperExprSyntax.self)) + } + + /// Visit a ``SuppressedTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SuppressedTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(SuppressedTypeSyntax.self)) + } + + /// Visit a ``SwitchCaseItemListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseItemListSyntax) async -> SwitchCaseItemListSyntax { + return await visitChildren(node._syntaxNode).cast(SwitchCaseItemListSyntax.self) + } + + /// Visit a ``SwitchCaseItemSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseItemSyntax) async -> SwitchCaseItemSyntax { + return await visitChildren(node._syntaxNode).cast(SwitchCaseItemSyntax.self) + } + + /// Visit a ``SwitchCaseLabelSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseLabelSyntax) async -> SwitchCaseLabelSyntax { + return await visitChildren(node._syntaxNode).cast(SwitchCaseLabelSyntax.self) + } + + /// Visit a ``SwitchCaseListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseListSyntax) async -> SwitchCaseListSyntax { + return await visitChildren(node._syntaxNode).cast(SwitchCaseListSyntax.self) + } + + /// Visit a ``SwitchCaseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchCaseSyntax) async -> SwitchCaseSyntax { + return await visitChildren(node._syntaxNode).cast(SwitchCaseSyntax.self) + } + + /// Visit a ``SwitchDefaultLabelSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchDefaultLabelSyntax) async -> SwitchDefaultLabelSyntax { + return await visitChildren(node._syntaxNode).cast(SwitchDefaultLabelSyntax.self) + } + + /// Visit a ``SwitchExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: SwitchExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(SwitchExprSyntax.self)) + } + + /// Visit a ``TernaryExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TernaryExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(TernaryExprSyntax.self)) + } + + /// Visit a `ThenStmtSyntax`. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + #if compiler(>=5.8) + @_spi(ExperimentalLanguageFeatures) + #endif + open func visit(_ node: ThenStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(ThenStmtSyntax.self)) + } + + /// Visit a ``ThrowStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ThrowStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(ThrowStmtSyntax.self)) + } + + /// Visit a ``ThrowsClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ThrowsClauseSyntax) async -> ThrowsClauseSyntax { + return await visitChildren(node._syntaxNode).cast(ThrowsClauseSyntax.self) + } + + /// Visit a ``TryExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TryExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(TryExprSyntax.self)) + } + + /// Visit a ``TupleExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TupleExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(TupleExprSyntax.self)) + } + + /// Visit a ``TuplePatternElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TuplePatternElementListSyntax) async -> TuplePatternElementListSyntax { + return await visitChildren(node._syntaxNode).cast(TuplePatternElementListSyntax.self) + } + + /// Visit a ``TuplePatternElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TuplePatternElementSyntax) async -> TuplePatternElementSyntax { + return await visitChildren(node._syntaxNode).cast(TuplePatternElementSyntax.self) + } + + /// Visit a ``TuplePatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TuplePatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(TuplePatternSyntax.self)) + } + + /// Visit a ``TupleTypeElementListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TupleTypeElementListSyntax) async -> TupleTypeElementListSyntax { + return await visitChildren(node._syntaxNode).cast(TupleTypeElementListSyntax.self) + } + + /// Visit a ``TupleTypeElementSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TupleTypeElementSyntax) async -> TupleTypeElementSyntax { + return await visitChildren(node._syntaxNode).cast(TupleTypeElementSyntax.self) + } + + /// Visit a ``TupleTypeSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TupleTypeSyntax) async -> TypeSyntax { + return TypeSyntax(await visitChildren(node._syntaxNode).cast(TupleTypeSyntax.self)) + } + + /// Visit a ``TypeAliasDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TypeAliasDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(TypeAliasDeclSyntax.self)) + } + + /// Visit a ``TypeAnnotationSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TypeAnnotationSyntax) async -> TypeAnnotationSyntax { + return await visitChildren(node._syntaxNode).cast(TypeAnnotationSyntax.self) + } + + /// Visit a ``TypeEffectSpecifiersSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TypeEffectSpecifiersSyntax) async -> TypeEffectSpecifiersSyntax { + return await visitChildren(node._syntaxNode).cast(TypeEffectSpecifiersSyntax.self) + } + + /// Visit a ``TypeExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TypeExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(TypeExprSyntax.self)) + } + + /// Visit a ``TypeInitializerClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TypeInitializerClauseSyntax) async -> TypeInitializerClauseSyntax { + return await visitChildren(node._syntaxNode).cast(TypeInitializerClauseSyntax.self) + } + + /// Visit a ``TypeSpecifierListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: TypeSpecifierListSyntax) async -> TypeSpecifierListSyntax { + return await visitChildren(node._syntaxNode).cast(TypeSpecifierListSyntax.self) + } + + /// Visit a ``UnavailableFromAsyncAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: UnavailableFromAsyncAttributeArgumentsSyntax) async -> UnavailableFromAsyncAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(UnavailableFromAsyncAttributeArgumentsSyntax.self) + } + + /// Visit a ``UnderscorePrivateAttributeArgumentsSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: UnderscorePrivateAttributeArgumentsSyntax) async -> UnderscorePrivateAttributeArgumentsSyntax { + return await visitChildren(node._syntaxNode).cast(UnderscorePrivateAttributeArgumentsSyntax.self) + } + + /// Visit a ``UnexpectedNodesSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: UnexpectedNodesSyntax) async -> UnexpectedNodesSyntax { + return await visitChildren(node._syntaxNode).cast(UnexpectedNodesSyntax.self) + } + + /// Visit a ``UnresolvedAsExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: UnresolvedAsExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(UnresolvedAsExprSyntax.self)) + } + + /// Visit a ``UnresolvedIsExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: UnresolvedIsExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(UnresolvedIsExprSyntax.self)) + } + + /// Visit a ``UnresolvedTernaryExprSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: UnresolvedTernaryExprSyntax) async -> ExprSyntax { + return ExprSyntax(await visitChildren(node._syntaxNode).cast(UnresolvedTernaryExprSyntax.self)) + } + + /// Visit a ``ValueBindingPatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: ValueBindingPatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(ValueBindingPatternSyntax.self)) + } + + /// Visit a ``VariableDeclSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: VariableDeclSyntax) async -> DeclSyntax { + return DeclSyntax(await visitChildren(node._syntaxNode).cast(VariableDeclSyntax.self)) + } + + /// Visit a ``VersionComponentListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: VersionComponentListSyntax) async -> VersionComponentListSyntax { + return await visitChildren(node._syntaxNode).cast(VersionComponentListSyntax.self) + } + + /// Visit a ``VersionComponentSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: VersionComponentSyntax) async -> VersionComponentSyntax { + return await visitChildren(node._syntaxNode).cast(VersionComponentSyntax.self) + } + + /// Visit a ``VersionTupleSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: VersionTupleSyntax) async -> VersionTupleSyntax { + return await visitChildren(node._syntaxNode).cast(VersionTupleSyntax.self) + } + + /// Visit a ``WhereClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: WhereClauseSyntax) async -> WhereClauseSyntax { + return await visitChildren(node._syntaxNode).cast(WhereClauseSyntax.self) + } + + /// Visit a ``WhileStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: WhileStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(WhileStmtSyntax.self)) + } + + /// Visit a ``WildcardPatternSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: WildcardPatternSyntax) async -> PatternSyntax { + return PatternSyntax(await visitChildren(node._syntaxNode).cast(WildcardPatternSyntax.self)) + } + + /// Visit a ``YieldStmtSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: YieldStmtSyntax) async -> StmtSyntax { + return StmtSyntax(await visitChildren(node._syntaxNode).cast(YieldStmtSyntax.self)) + } + + /// Visit a ``YieldedExpressionListSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: YieldedExpressionListSyntax) async -> YieldedExpressionListSyntax { + return await visitChildren(node._syntaxNode).cast(YieldedExpressionListSyntax.self) + } + + /// Visit a ``YieldedExpressionSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: YieldedExpressionSyntax) async -> YieldedExpressionSyntax { + return await visitChildren(node._syntaxNode).cast(YieldedExpressionSyntax.self) + } + + /// Visit a ``YieldedExpressionsClauseSyntax``. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + open func visit(_ node: YieldedExpressionsClauseSyntax) async -> YieldedExpressionsClauseSyntax { + return await visitChildren(node._syntaxNode).cast(YieldedExpressionsClauseSyntax.self) + } + + /// Visit any DeclSyntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + public func visit(_ node: DeclSyntax) async -> DeclSyntax { + var node: Syntax = Syntax(node) + await dispatchVisit(&node) + return node.cast(DeclSyntax.self) + } + + /// Visit any ExprSyntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + public func visit(_ node: ExprSyntax) async -> ExprSyntax { + var node: Syntax = Syntax(node) + await dispatchVisit(&node) + return node.cast(ExprSyntax.self) + } + + /// Visit any PatternSyntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + public func visit(_ node: PatternSyntax) async -> PatternSyntax { + var node: Syntax = Syntax(node) + await dispatchVisit(&node) + return node.cast(PatternSyntax.self) + } + + /// Visit any StmtSyntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + public func visit(_ node: StmtSyntax) async -> StmtSyntax { + var node: Syntax = Syntax(node) + await dispatchVisit(&node) + return node.cast(StmtSyntax.self) + } + + /// Visit any TypeSyntax node. + /// - Parameter node: the node that is being visited + /// - Returns: the rewritten node + public func visit(_ node: TypeSyntax) async -> TypeSyntax { + var node: Syntax = Syntax(node) + await dispatchVisit(&node) + return node.cast(TypeSyntax.self) + } + + /// Interpret `node` as a node of type `nodeType`, visit it, calling + /// the `visit` to transform the node. + @inline(__always) + private func visitImpl( + _ node: inout Syntax, + _ nodeType: NodeType.Type, + _ visit: (NodeType) async -> some SyntaxProtocol + ) async { + let origNode = node + await visitPre(origNode) + node = if let newNode = await visitAny(origNode) { + newNode + } else { + await Syntax(visit(origNode.cast(NodeType.self))) + } + await visitPost(origNode) + } + + // SwiftSyntax requires a lot of stack space in debug builds for syntax tree + // rewriting. In scenarios with reduced stack space (in particular dispatch + // queues), this easily results in a stack overflow. To work around this issue, + // use a less performant but also less stack-hungry version of SwiftSyntax's + // AsyncSyntaxRewriter in debug builds. + #if DEBUG + /// Implementation detail of visit(_:). Do not call directly. + /// + /// Returns the function that shall be called to visit a specific syntax node. + /// + /// To determine the correct specific visitation function for a syntax node, + /// we need to switch through a huge switch statement that covers all syntax + /// types. In debug builds, the cases of this switch statement do not share + /// stack space (rdar://55929175). Because of this, the switch statement + /// requires about 15KB of stack space. In scenarios with reduced + /// stack size (in particular dispatch queues), this often results in a stack + /// overflow during syntax tree rewriting. + /// + /// To circumvent this problem, make calling the specific visitation function + /// a two-step process: First determine the function to call in this function + /// and return a reference to it, then call it. This way, the stack frame + /// that determines the correct visitation function will be popped of the + /// stack before the function is being called, making the switch's stack + /// space transient instead of having it linger in the call stack. + private func visitationFunc(for node: Syntax) async -> ((inout Syntax) async -> Void) { + switch node.raw.kind { + case .token: + return { + await self.visitImpl(&$0, TokenSyntax.self, self.visit) + } + case .accessorBlock: + return { + await self.visitImpl(&$0, AccessorBlockSyntax.self, self.visit) + } + case .accessorDeclList: + return { + await self.visitImpl(&$0, AccessorDeclListSyntax.self, self.visit) + } + case .accessorDecl: + return { + await self.visitImpl(&$0, AccessorDeclSyntax.self, self.visit) + } + case .accessorEffectSpecifiers: + return { + await self.visitImpl(&$0, AccessorEffectSpecifiersSyntax.self, self.visit) + } + case .accessorParameters: + return { + await self.visitImpl(&$0, AccessorParametersSyntax.self, self.visit) + } + case .actorDecl: + return { + await self.visitImpl(&$0, ActorDeclSyntax.self, self.visit) + } + case .arrayElementList: + return { + await self.visitImpl(&$0, ArrayElementListSyntax.self, self.visit) + } + case .arrayElement: + return { + await self.visitImpl(&$0, ArrayElementSyntax.self, self.visit) + } + case .arrayExpr: + return { + await self.visitImpl(&$0, ArrayExprSyntax.self, self.visit) + } + case .arrayType: + return { + await self.visitImpl(&$0, ArrayTypeSyntax.self, self.visit) + } + case .arrowExpr: + return { + await self.visitImpl(&$0, ArrowExprSyntax.self, self.visit) + } + case .asExpr: + return { + await self.visitImpl(&$0, AsExprSyntax.self, self.visit) + } + case .assignmentExpr: + return { + await self.visitImpl(&$0, AssignmentExprSyntax.self, self.visit) + } + case .associatedTypeDecl: + return { + await self.visitImpl(&$0, AssociatedTypeDeclSyntax.self, self.visit) + } + case .attributeList: + return { + await self.visitImpl(&$0, AttributeListSyntax.self, self.visit) + } + case .attribute: + return { + await self.visitImpl(&$0, AttributeSyntax.self, self.visit) + } + case .attributedType: + return { + await self.visitImpl(&$0, AttributedTypeSyntax.self, self.visit) + } + case .availabilityArgumentList: + return { + await self.visitImpl(&$0, AvailabilityArgumentListSyntax.self, self.visit) + } + case .availabilityArgument: + return { + await self.visitImpl(&$0, AvailabilityArgumentSyntax.self, self.visit) + } + case .availabilityCondition: + return { + await self.visitImpl(&$0, AvailabilityConditionSyntax.self, self.visit) + } + case .availabilityLabeledArgument: + return { + await self.visitImpl(&$0, AvailabilityLabeledArgumentSyntax.self, self.visit) + } + case .awaitExpr: + return { + await self.visitImpl(&$0, AwaitExprSyntax.self, self.visit) + } + case .backDeployedAttributeArguments: + return { + await self.visitImpl(&$0, BackDeployedAttributeArgumentsSyntax.self, self.visit) + } + case .binaryOperatorExpr: + return { + await self.visitImpl(&$0, BinaryOperatorExprSyntax.self, self.visit) + } + case .booleanLiteralExpr: + return { + await self.visitImpl(&$0, BooleanLiteralExprSyntax.self, self.visit) + } + case .borrowExpr: + return { + await self.visitImpl(&$0, BorrowExprSyntax.self, self.visit) + } + case .breakStmt: + return { + await self.visitImpl(&$0, BreakStmtSyntax.self, self.visit) + } + case ._canImportExpr: + return { + await self.visitImpl(&$0, _CanImportExprSyntax.self, self.visit) + } + case ._canImportVersionInfo: + return { + await self.visitImpl(&$0, _CanImportVersionInfoSyntax.self, self.visit) + } + case .catchClauseList: + return { + await self.visitImpl(&$0, CatchClauseListSyntax.self, self.visit) + } + case .catchClause: + return { + await self.visitImpl(&$0, CatchClauseSyntax.self, self.visit) + } + case .catchItemList: + return { + await self.visitImpl(&$0, CatchItemListSyntax.self, self.visit) + } + case .catchItem: + return { + await self.visitImpl(&$0, CatchItemSyntax.self, self.visit) + } + case .classDecl: + return { + await self.visitImpl(&$0, ClassDeclSyntax.self, self.visit) + } + case .classRestrictionType: + return { + await self.visitImpl(&$0, ClassRestrictionTypeSyntax.self, self.visit) + } + case .closureCaptureClause: + return { + await self.visitImpl(&$0, ClosureCaptureClauseSyntax.self, self.visit) + } + case .closureCaptureList: + return { + await self.visitImpl(&$0, ClosureCaptureListSyntax.self, self.visit) + } + case .closureCaptureSpecifier: + return { + await self.visitImpl(&$0, ClosureCaptureSpecifierSyntax.self, self.visit) + } + case .closureCapture: + return { + await self.visitImpl(&$0, ClosureCaptureSyntax.self, self.visit) + } + case .closureExpr: + return { + await self.visitImpl(&$0, ClosureExprSyntax.self, self.visit) + } + case .closureParameterClause: + return { + await self.visitImpl(&$0, ClosureParameterClauseSyntax.self, self.visit) + } + case .closureParameterList: + return { + await self.visitImpl(&$0, ClosureParameterListSyntax.self, self.visit) + } + case .closureParameter: + return { + await self.visitImpl(&$0, ClosureParameterSyntax.self, self.visit) + } + case .closureShorthandParameterList: + return { + await self.visitImpl(&$0, ClosureShorthandParameterListSyntax.self, self.visit) + } + case .closureShorthandParameter: + return { + await self.visitImpl(&$0, ClosureShorthandParameterSyntax.self, self.visit) + } + case .closureSignature: + return { + await self.visitImpl(&$0, ClosureSignatureSyntax.self, self.visit) + } + case .codeBlockItemList: + return { + await self.visitImpl(&$0, CodeBlockItemListSyntax.self, self.visit) + } + case .codeBlockItem: + return { + await self.visitImpl(&$0, CodeBlockItemSyntax.self, self.visit) + } + case .codeBlock: + return { + await self.visitImpl(&$0, CodeBlockSyntax.self, self.visit) + } + case .compositionTypeElementList: + return { + await self.visitImpl(&$0, CompositionTypeElementListSyntax.self, self.visit) + } + case .compositionTypeElement: + return { + await self.visitImpl(&$0, CompositionTypeElementSyntax.self, self.visit) + } + case .compositionType: + return { + await self.visitImpl(&$0, CompositionTypeSyntax.self, self.visit) + } + case .conditionElementList: + return { + await self.visitImpl(&$0, ConditionElementListSyntax.self, self.visit) + } + case .conditionElement: + return { + await self.visitImpl(&$0, ConditionElementSyntax.self, self.visit) + } + case .conformanceRequirement: + return { + await self.visitImpl(&$0, ConformanceRequirementSyntax.self, self.visit) + } + case .consumeExpr: + return { + await self.visitImpl(&$0, ConsumeExprSyntax.self, self.visit) + } + case .continueStmt: + return { + await self.visitImpl(&$0, ContinueStmtSyntax.self, self.visit) + } + case .conventionAttributeArguments: + return { + await self.visitImpl(&$0, ConventionAttributeArgumentsSyntax.self, self.visit) + } + case .conventionWitnessMethodAttributeArguments: + return { + await self.visitImpl(&$0, ConventionWitnessMethodAttributeArgumentsSyntax.self, self.visit) + } + case .copyExpr: + return { + await self.visitImpl(&$0, CopyExprSyntax.self, self.visit) + } + case .declModifierDetail: + return { + await self.visitImpl(&$0, DeclModifierDetailSyntax.self, self.visit) + } + case .declModifierList: + return { + await self.visitImpl(&$0, DeclModifierListSyntax.self, self.visit) + } + case .declModifier: + return { + await self.visitImpl(&$0, DeclModifierSyntax.self, self.visit) + } + case .declNameArgumentList: + return { + await self.visitImpl(&$0, DeclNameArgumentListSyntax.self, self.visit) + } + case .declNameArgument: + return { + await self.visitImpl(&$0, DeclNameArgumentSyntax.self, self.visit) + } + case .declNameArguments: + return { + await self.visitImpl(&$0, DeclNameArgumentsSyntax.self, self.visit) + } + case .declReferenceExpr: + return { + await self.visitImpl(&$0, DeclReferenceExprSyntax.self, self.visit) + } + case .deferStmt: + return { + await self.visitImpl(&$0, DeferStmtSyntax.self, self.visit) + } + case .deinitializerDecl: + return { + await self.visitImpl(&$0, DeinitializerDeclSyntax.self, self.visit) + } + case .deinitializerEffectSpecifiers: + return { + await self.visitImpl(&$0, DeinitializerEffectSpecifiersSyntax.self, self.visit) + } + case .derivativeAttributeArguments: + return { + await self.visitImpl(&$0, DerivativeAttributeArgumentsSyntax.self, self.visit) + } + case .designatedTypeList: + return { + await self.visitImpl(&$0, DesignatedTypeListSyntax.self, self.visit) + } + case .designatedType: + return { + await self.visitImpl(&$0, DesignatedTypeSyntax.self, self.visit) + } + case .dictionaryElementList: + return { + await self.visitImpl(&$0, DictionaryElementListSyntax.self, self.visit) + } + case .dictionaryElement: + return { + await self.visitImpl(&$0, DictionaryElementSyntax.self, self.visit) + } + case .dictionaryExpr: + return { + await self.visitImpl(&$0, DictionaryExprSyntax.self, self.visit) + } + case .dictionaryType: + return { + await self.visitImpl(&$0, DictionaryTypeSyntax.self, self.visit) + } + case .differentiabilityArgumentList: + return { + await self.visitImpl(&$0, DifferentiabilityArgumentListSyntax.self, self.visit) + } + case .differentiabilityArgument: + return { + await self.visitImpl(&$0, DifferentiabilityArgumentSyntax.self, self.visit) + } + case .differentiabilityArguments: + return { + await self.visitImpl(&$0, DifferentiabilityArgumentsSyntax.self, self.visit) + } + case .differentiabilityWithRespectToArgument: + return { + await self.visitImpl(&$0, DifferentiabilityWithRespectToArgumentSyntax.self, self.visit) + } + case .differentiableAttributeArguments: + return { + await self.visitImpl(&$0, DifferentiableAttributeArgumentsSyntax.self, self.visit) + } + case .discardAssignmentExpr: + return { + await self.visitImpl(&$0, DiscardAssignmentExprSyntax.self, self.visit) + } + case .discardStmt: + return { + await self.visitImpl(&$0, DiscardStmtSyntax.self, self.visit) + } + case .doExpr: + return { + await self.visitImpl(&$0, DoExprSyntax.self, self.visit) + } + case .doStmt: + return { + await self.visitImpl(&$0, DoStmtSyntax.self, self.visit) + } + case .documentationAttributeArgumentList: + return { + await self.visitImpl(&$0, DocumentationAttributeArgumentListSyntax.self, self.visit) + } + case .documentationAttributeArgument: + return { + await self.visitImpl(&$0, DocumentationAttributeArgumentSyntax.self, self.visit) + } + case .dynamicReplacementAttributeArguments: + return { + await self.visitImpl(&$0, DynamicReplacementAttributeArgumentsSyntax.self, self.visit) + } + case .editorPlaceholderDecl: + return { + await self.visitImpl(&$0, EditorPlaceholderDeclSyntax.self, self.visit) + } + case .editorPlaceholderExpr: + return { + await self.visitImpl(&$0, EditorPlaceholderExprSyntax.self, self.visit) + } + case .effectsAttributeArgumentList: + return { + await self.visitImpl(&$0, EffectsAttributeArgumentListSyntax.self, self.visit) + } + case .enumCaseDecl: + return { + await self.visitImpl(&$0, EnumCaseDeclSyntax.self, self.visit) + } + case .enumCaseElementList: + return { + await self.visitImpl(&$0, EnumCaseElementListSyntax.self, self.visit) + } + case .enumCaseElement: + return { + await self.visitImpl(&$0, EnumCaseElementSyntax.self, self.visit) + } + case .enumCaseParameterClause: + return { + await self.visitImpl(&$0, EnumCaseParameterClauseSyntax.self, self.visit) + } + case .enumCaseParameterList: + return { + await self.visitImpl(&$0, EnumCaseParameterListSyntax.self, self.visit) + } + case .enumCaseParameter: + return { + await self.visitImpl(&$0, EnumCaseParameterSyntax.self, self.visit) + } + case .enumDecl: + return { + await self.visitImpl(&$0, EnumDeclSyntax.self, self.visit) + } + case .exposeAttributeArguments: + return { + await self.visitImpl(&$0, ExposeAttributeArgumentsSyntax.self, self.visit) + } + case .exprList: + return { + await self.visitImpl(&$0, ExprListSyntax.self, self.visit) + } + case .expressionPattern: + return { + await self.visitImpl(&$0, ExpressionPatternSyntax.self, self.visit) + } + case .expressionSegment: + return { + await self.visitImpl(&$0, ExpressionSegmentSyntax.self, self.visit) + } + case .expressionStmt: + return { + await self.visitImpl(&$0, ExpressionStmtSyntax.self, self.visit) + } + case .extensionDecl: + return { + await self.visitImpl(&$0, ExtensionDeclSyntax.self, self.visit) + } + case .fallThroughStmt: + return { + await self.visitImpl(&$0, FallThroughStmtSyntax.self, self.visit) + } + case .floatLiteralExpr: + return { + await self.visitImpl(&$0, FloatLiteralExprSyntax.self, self.visit) + } + case .forStmt: + return { + await self.visitImpl(&$0, ForStmtSyntax.self, self.visit) + } + case .forceUnwrapExpr: + return { + await self.visitImpl(&$0, ForceUnwrapExprSyntax.self, self.visit) + } + case .functionCallExpr: + return { + await self.visitImpl(&$0, FunctionCallExprSyntax.self, self.visit) + } + case .functionDecl: + return { + await self.visitImpl(&$0, FunctionDeclSyntax.self, self.visit) + } + case .functionEffectSpecifiers: + return { + await self.visitImpl(&$0, FunctionEffectSpecifiersSyntax.self, self.visit) + } + case .functionParameterClause: + return { + await self.visitImpl(&$0, FunctionParameterClauseSyntax.self, self.visit) + } + case .functionParameterList: + return { + await self.visitImpl(&$0, FunctionParameterListSyntax.self, self.visit) + } + case .functionParameter: + return { + await self.visitImpl(&$0, FunctionParameterSyntax.self, self.visit) + } + case .functionSignature: + return { + await self.visitImpl(&$0, FunctionSignatureSyntax.self, self.visit) + } + case .functionType: + return { + await self.visitImpl(&$0, FunctionTypeSyntax.self, self.visit) + } + case .genericArgumentClause: + return { + await self.visitImpl(&$0, GenericArgumentClauseSyntax.self, self.visit) + } + case .genericArgumentList: + return { + await self.visitImpl(&$0, GenericArgumentListSyntax.self, self.visit) + } + case .genericArgument: + return { + await self.visitImpl(&$0, GenericArgumentSyntax.self, self.visit) + } + case .genericParameterClause: + return { + await self.visitImpl(&$0, GenericParameterClauseSyntax.self, self.visit) + } + case .genericParameterList: + return { + await self.visitImpl(&$0, GenericParameterListSyntax.self, self.visit) + } + case .genericParameter: + return { + await self.visitImpl(&$0, GenericParameterSyntax.self, self.visit) + } + case .genericRequirementList: + return { + await self.visitImpl(&$0, GenericRequirementListSyntax.self, self.visit) + } + case .genericRequirement: + return { + await self.visitImpl(&$0, GenericRequirementSyntax.self, self.visit) + } + case .genericSpecializationExpr: + return { + await self.visitImpl(&$0, GenericSpecializationExprSyntax.self, self.visit) + } + case .genericWhereClause: + return { + await self.visitImpl(&$0, GenericWhereClauseSyntax.self, self.visit) + } + case .guardStmt: + return { + await self.visitImpl(&$0, GuardStmtSyntax.self, self.visit) + } + case .identifierPattern: + return { + await self.visitImpl(&$0, IdentifierPatternSyntax.self, self.visit) + } + case .identifierType: + return { + await self.visitImpl(&$0, IdentifierTypeSyntax.self, self.visit) + } + case .ifConfigClauseList: + return { + await self.visitImpl(&$0, IfConfigClauseListSyntax.self, self.visit) + } + case .ifConfigClause: + return { + await self.visitImpl(&$0, IfConfigClauseSyntax.self, self.visit) + } + case .ifConfigDecl: + return { + await self.visitImpl(&$0, IfConfigDeclSyntax.self, self.visit) + } + case .ifExpr: + return { + await self.visitImpl(&$0, IfExprSyntax.self, self.visit) + } + case .implementsAttributeArguments: + return { + await self.visitImpl(&$0, ImplementsAttributeArgumentsSyntax.self, self.visit) + } + case .implicitlyUnwrappedOptionalType: + return { + await self.visitImpl(&$0, ImplicitlyUnwrappedOptionalTypeSyntax.self, self.visit) + } + case .importDecl: + return { + await self.visitImpl(&$0, ImportDeclSyntax.self, self.visit) + } + case .importPathComponentList: + return { + await self.visitImpl(&$0, ImportPathComponentListSyntax.self, self.visit) + } + case .importPathComponent: + return { + await self.visitImpl(&$0, ImportPathComponentSyntax.self, self.visit) + } + case .inOutExpr: + return { + await self.visitImpl(&$0, InOutExprSyntax.self, self.visit) + } + case .infixOperatorExpr: + return { + await self.visitImpl(&$0, InfixOperatorExprSyntax.self, self.visit) + } + case .inheritanceClause: + return { + await self.visitImpl(&$0, InheritanceClauseSyntax.self, self.visit) + } + case .inheritedTypeList: + return { + await self.visitImpl(&$0, InheritedTypeListSyntax.self, self.visit) + } + case .inheritedType: + return { + await self.visitImpl(&$0, InheritedTypeSyntax.self, self.visit) + } + case .initializerClause: + return { + await self.visitImpl(&$0, InitializerClauseSyntax.self, self.visit) + } + case .initializerDecl: + return { + await self.visitImpl(&$0, InitializerDeclSyntax.self, self.visit) + } + case .integerLiteralExpr: + return { + await self.visitImpl(&$0, IntegerLiteralExprSyntax.self, self.visit) + } + case .isExpr: + return { + await self.visitImpl(&$0, IsExprSyntax.self, self.visit) + } + case .isTypePattern: + return { + await self.visitImpl(&$0, IsTypePatternSyntax.self, self.visit) + } + case .keyPathComponentList: + return { + await self.visitImpl(&$0, KeyPathComponentListSyntax.self, self.visit) + } + case .keyPathComponent: + return { + await self.visitImpl(&$0, KeyPathComponentSyntax.self, self.visit) + } + case .keyPathExpr: + return { + await self.visitImpl(&$0, KeyPathExprSyntax.self, self.visit) + } + case .keyPathOptionalComponent: + return { + await self.visitImpl(&$0, KeyPathOptionalComponentSyntax.self, self.visit) + } + case .keyPathPropertyComponent: + return { + await self.visitImpl(&$0, KeyPathPropertyComponentSyntax.self, self.visit) + } + case .keyPathSubscriptComponent: + return { + await self.visitImpl(&$0, KeyPathSubscriptComponentSyntax.self, self.visit) + } + case .labeledExprList: + return { + await self.visitImpl(&$0, LabeledExprListSyntax.self, self.visit) + } + case .labeledExpr: + return { + await self.visitImpl(&$0, LabeledExprSyntax.self, self.visit) + } + case .labeledSpecializeArgument: + return { + await self.visitImpl(&$0, LabeledSpecializeArgumentSyntax.self, self.visit) + } + case .labeledStmt: + return { + await self.visitImpl(&$0, LabeledStmtSyntax.self, self.visit) + } + case .layoutRequirement: + return { + await self.visitImpl(&$0, LayoutRequirementSyntax.self, self.visit) + } + case .lifetimeSpecifierArgumentList: + return { + await self.visitImpl(&$0, LifetimeSpecifierArgumentListSyntax.self, self.visit) + } + case .lifetimeSpecifierArgument: + return { + await self.visitImpl(&$0, LifetimeSpecifierArgumentSyntax.self, self.visit) + } + case .lifetimeTypeSpecifier: + return { + await self.visitImpl(&$0, LifetimeTypeSpecifierSyntax.self, self.visit) + } + case .macroDecl: + return { + await self.visitImpl(&$0, MacroDeclSyntax.self, self.visit) + } + case .macroExpansionDecl: + return { + await self.visitImpl(&$0, MacroExpansionDeclSyntax.self, self.visit) + } + case .macroExpansionExpr: + return { + await self.visitImpl(&$0, MacroExpansionExprSyntax.self, self.visit) + } + case .matchingPatternCondition: + return { + await self.visitImpl(&$0, MatchingPatternConditionSyntax.self, self.visit) + } + case .memberAccessExpr: + return { + await self.visitImpl(&$0, MemberAccessExprSyntax.self, self.visit) + } + case .memberBlockItemList: + return { + await self.visitImpl(&$0, MemberBlockItemListSyntax.self, self.visit) + } + case .memberBlockItem: + return { + await self.visitImpl(&$0, MemberBlockItemSyntax.self, self.visit) + } + case .memberBlock: + return { + await self.visitImpl(&$0, MemberBlockSyntax.self, self.visit) + } + case .memberType: + return { + await self.visitImpl(&$0, MemberTypeSyntax.self, self.visit) + } + case .metatypeType: + return { + await self.visitImpl(&$0, MetatypeTypeSyntax.self, self.visit) + } + case .missingDecl: + return { + await self.visitImpl(&$0, MissingDeclSyntax.self, self.visit) + } + case .missingExpr: + return { + await self.visitImpl(&$0, MissingExprSyntax.self, self.visit) + } + case .missingPattern: + return { + await self.visitImpl(&$0, MissingPatternSyntax.self, self.visit) + } + case .missingStmt: + return { + await self.visitImpl(&$0, MissingStmtSyntax.self, self.visit) + } + case .missing: + return { + await self.visitImpl(&$0, MissingSyntax.self, self.visit) + } + case .missingType: + return { + await self.visitImpl(&$0, MissingTypeSyntax.self, self.visit) + } + case .multipleTrailingClosureElementList: + return { + await self.visitImpl(&$0, MultipleTrailingClosureElementListSyntax.self, self.visit) + } + case .multipleTrailingClosureElement: + return { + await self.visitImpl(&$0, MultipleTrailingClosureElementSyntax.self, self.visit) + } + case .namedOpaqueReturnType: + return { + await self.visitImpl(&$0, NamedOpaqueReturnTypeSyntax.self, self.visit) + } + case .nilLiteralExpr: + return { + await self.visitImpl(&$0, NilLiteralExprSyntax.self, self.visit) + } + case .objCSelectorPieceList: + return { + await self.visitImpl(&$0, ObjCSelectorPieceListSyntax.self, self.visit) + } + case .objCSelectorPiece: + return { + await self.visitImpl(&$0, ObjCSelectorPieceSyntax.self, self.visit) + } + case .opaqueReturnTypeOfAttributeArguments: + return { + await self.visitImpl(&$0, OpaqueReturnTypeOfAttributeArgumentsSyntax.self, self.visit) + } + case .operatorDecl: + return { + await self.visitImpl(&$0, OperatorDeclSyntax.self, self.visit) + } + case .operatorPrecedenceAndTypes: + return { + await self.visitImpl(&$0, OperatorPrecedenceAndTypesSyntax.self, self.visit) + } + case .optionalBindingCondition: + return { + await self.visitImpl(&$0, OptionalBindingConditionSyntax.self, self.visit) + } + case .optionalChainingExpr: + return { + await self.visitImpl(&$0, OptionalChainingExprSyntax.self, self.visit) + } + case .optionalType: + return { + await self.visitImpl(&$0, OptionalTypeSyntax.self, self.visit) + } + case .originallyDefinedInAttributeArguments: + return { + await self.visitImpl(&$0, OriginallyDefinedInAttributeArgumentsSyntax.self, self.visit) + } + case .packElementExpr: + return { + await self.visitImpl(&$0, PackElementExprSyntax.self, self.visit) + } + case .packElementType: + return { + await self.visitImpl(&$0, PackElementTypeSyntax.self, self.visit) + } + case .packExpansionExpr: + return { + await self.visitImpl(&$0, PackExpansionExprSyntax.self, self.visit) + } + case .packExpansionType: + return { + await self.visitImpl(&$0, PackExpansionTypeSyntax.self, self.visit) + } + case .patternBindingList: + return { + await self.visitImpl(&$0, PatternBindingListSyntax.self, self.visit) + } + case .patternBinding: + return { + await self.visitImpl(&$0, PatternBindingSyntax.self, self.visit) + } + case .patternExpr: + return { + await self.visitImpl(&$0, PatternExprSyntax.self, self.visit) + } + case .platformVersionItemList: + return { + await self.visitImpl(&$0, PlatformVersionItemListSyntax.self, self.visit) + } + case .platformVersionItem: + return { + await self.visitImpl(&$0, PlatformVersionItemSyntax.self, self.visit) + } + case .platformVersion: + return { + await self.visitImpl(&$0, PlatformVersionSyntax.self, self.visit) + } + case .postfixIfConfigExpr: + return { + await self.visitImpl(&$0, PostfixIfConfigExprSyntax.self, self.visit) + } + case .postfixOperatorExpr: + return { + await self.visitImpl(&$0, PostfixOperatorExprSyntax.self, self.visit) + } + case .poundSourceLocationArguments: + return { + await self.visitImpl(&$0, PoundSourceLocationArgumentsSyntax.self, self.visit) + } + case .poundSourceLocation: + return { + await self.visitImpl(&$0, PoundSourceLocationSyntax.self, self.visit) + } + case .precedenceGroupAssignment: + return { + await self.visitImpl(&$0, PrecedenceGroupAssignmentSyntax.self, self.visit) + } + case .precedenceGroupAssociativity: + return { + await self.visitImpl(&$0, PrecedenceGroupAssociativitySyntax.self, self.visit) + } + case .precedenceGroupAttributeList: + return { + await self.visitImpl(&$0, PrecedenceGroupAttributeListSyntax.self, self.visit) + } + case .precedenceGroupDecl: + return { + await self.visitImpl(&$0, PrecedenceGroupDeclSyntax.self, self.visit) + } + case .precedenceGroupNameList: + return { + await self.visitImpl(&$0, PrecedenceGroupNameListSyntax.self, self.visit) + } + case .precedenceGroupName: + return { + await self.visitImpl(&$0, PrecedenceGroupNameSyntax.self, self.visit) + } + case .precedenceGroupRelation: + return { + await self.visitImpl(&$0, PrecedenceGroupRelationSyntax.self, self.visit) + } + case .prefixOperatorExpr: + return { + await self.visitImpl(&$0, PrefixOperatorExprSyntax.self, self.visit) + } + case .primaryAssociatedTypeClause: + return { + await self.visitImpl(&$0, PrimaryAssociatedTypeClauseSyntax.self, self.visit) + } + case .primaryAssociatedTypeList: + return { + await self.visitImpl(&$0, PrimaryAssociatedTypeListSyntax.self, self.visit) + } + case .primaryAssociatedType: + return { + await self.visitImpl(&$0, PrimaryAssociatedTypeSyntax.self, self.visit) + } + case .protocolDecl: + return { + await self.visitImpl(&$0, ProtocolDeclSyntax.self, self.visit) + } + case .regexLiteralExpr: + return { + await self.visitImpl(&$0, RegexLiteralExprSyntax.self, self.visit) + } + case .repeatStmt: + return { + await self.visitImpl(&$0, RepeatStmtSyntax.self, self.visit) + } + case .returnClause: + return { + await self.visitImpl(&$0, ReturnClauseSyntax.self, self.visit) + } + case .returnStmt: + return { + await self.visitImpl(&$0, ReturnStmtSyntax.self, self.visit) + } + case .sameTypeRequirement: + return { + await self.visitImpl(&$0, SameTypeRequirementSyntax.self, self.visit) + } + case .sequenceExpr: + return { + await self.visitImpl(&$0, SequenceExprSyntax.self, self.visit) + } + case .simpleStringLiteralExpr: + return { + await self.visitImpl(&$0, SimpleStringLiteralExprSyntax.self, self.visit) + } + case .simpleStringLiteralSegmentList: + return { + await self.visitImpl(&$0, SimpleStringLiteralSegmentListSyntax.self, self.visit) + } + case .simpleTypeSpecifier: + return { + await self.visitImpl(&$0, SimpleTypeSpecifierSyntax.self, self.visit) + } + case .someOrAnyType: + return { + await self.visitImpl(&$0, SomeOrAnyTypeSyntax.self, self.visit) + } + case .sourceFile: + return { + await self.visitImpl(&$0, SourceFileSyntax.self, self.visit) + } + case .specializeAttributeArgumentList: + return { + await self.visitImpl(&$0, SpecializeAttributeArgumentListSyntax.self, self.visit) + } + case .specializeAvailabilityArgument: + return { + await self.visitImpl(&$0, SpecializeAvailabilityArgumentSyntax.self, self.visit) + } + case .specializeTargetFunctionArgument: + return { + await self.visitImpl(&$0, SpecializeTargetFunctionArgumentSyntax.self, self.visit) + } + case .stringLiteralExpr: + return { + await self.visitImpl(&$0, StringLiteralExprSyntax.self, self.visit) + } + case .stringLiteralSegmentList: + return { + await self.visitImpl(&$0, StringLiteralSegmentListSyntax.self, self.visit) + } + case .stringSegment: + return { + await self.visitImpl(&$0, StringSegmentSyntax.self, self.visit) + } + case .structDecl: + return { + await self.visitImpl(&$0, StructDeclSyntax.self, self.visit) + } + case .subscriptCallExpr: + return { + await self.visitImpl(&$0, SubscriptCallExprSyntax.self, self.visit) + } + case .subscriptDecl: + return { + await self.visitImpl(&$0, SubscriptDeclSyntax.self, self.visit) + } + case .superExpr: + return { + await self.visitImpl(&$0, SuperExprSyntax.self, self.visit) + } + case .suppressedType: + return { + await self.visitImpl(&$0, SuppressedTypeSyntax.self, self.visit) + } + case .switchCaseItemList: + return { + await self.visitImpl(&$0, SwitchCaseItemListSyntax.self, self.visit) + } + case .switchCaseItem: + return { + await self.visitImpl(&$0, SwitchCaseItemSyntax.self, self.visit) + } + case .switchCaseLabel: + return { + await self.visitImpl(&$0, SwitchCaseLabelSyntax.self, self.visit) + } + case .switchCaseList: + return { + await self.visitImpl(&$0, SwitchCaseListSyntax.self, self.visit) + } + case .switchCase: + return { + await self.visitImpl(&$0, SwitchCaseSyntax.self, self.visit) + } + case .switchDefaultLabel: + return { + await self.visitImpl(&$0, SwitchDefaultLabelSyntax.self, self.visit) + } + case .switchExpr: + return { + await self.visitImpl(&$0, SwitchExprSyntax.self, self.visit) + } + case .ternaryExpr: + return { + await self.visitImpl(&$0, TernaryExprSyntax.self, self.visit) + } + case .thenStmt: + return { + await self.visitImpl(&$0, ThenStmtSyntax.self, self.visit) + } + case .throwStmt: + return { + await self.visitImpl(&$0, ThrowStmtSyntax.self, self.visit) + } + case .throwsClause: + return { + await self.visitImpl(&$0, ThrowsClauseSyntax.self, self.visit) + } + case .tryExpr: + return { + await self.visitImpl(&$0, TryExprSyntax.self, self.visit) + } + case .tupleExpr: + return { + await self.visitImpl(&$0, TupleExprSyntax.self, self.visit) + } + case .tuplePatternElementList: + return { + await self.visitImpl(&$0, TuplePatternElementListSyntax.self, self.visit) + } + case .tuplePatternElement: + return { + await self.visitImpl(&$0, TuplePatternElementSyntax.self, self.visit) + } + case .tuplePattern: + return { + await self.visitImpl(&$0, TuplePatternSyntax.self, self.visit) + } + case .tupleTypeElementList: + return { + await self.visitImpl(&$0, TupleTypeElementListSyntax.self, self.visit) + } + case .tupleTypeElement: + return { + await self.visitImpl(&$0, TupleTypeElementSyntax.self, self.visit) + } + case .tupleType: + return { + await self.visitImpl(&$0, TupleTypeSyntax.self, self.visit) + } + case .typeAliasDecl: + return { + await self.visitImpl(&$0, TypeAliasDeclSyntax.self, self.visit) + } + case .typeAnnotation: + return { + await self.visitImpl(&$0, TypeAnnotationSyntax.self, self.visit) + } + case .typeEffectSpecifiers: + return { + await self.visitImpl(&$0, TypeEffectSpecifiersSyntax.self, self.visit) + } + case .typeExpr: + return { + await self.visitImpl(&$0, TypeExprSyntax.self, self.visit) + } + case .typeInitializerClause: + return { + await self.visitImpl(&$0, TypeInitializerClauseSyntax.self, self.visit) + } + case .typeSpecifierList: + return { + await self.visitImpl(&$0, TypeSpecifierListSyntax.self, self.visit) + } + case .unavailableFromAsyncAttributeArguments: + return { + await self.visitImpl(&$0, UnavailableFromAsyncAttributeArgumentsSyntax.self, self.visit) + } + case .underscorePrivateAttributeArguments: + return { + await self.visitImpl(&$0, UnderscorePrivateAttributeArgumentsSyntax.self, self.visit) + } + case .unexpectedNodes: + return { + await self.visitImpl(&$0, UnexpectedNodesSyntax.self, self.visit) + } + case .unresolvedAsExpr: + return { + await self.visitImpl(&$0, UnresolvedAsExprSyntax.self, self.visit) + } + case .unresolvedIsExpr: + return { + await self.visitImpl(&$0, UnresolvedIsExprSyntax.self, self.visit) + } + case .unresolvedTernaryExpr: + return { + await self.visitImpl(&$0, UnresolvedTernaryExprSyntax.self, self.visit) + } + case .valueBindingPattern: + return { + await self.visitImpl(&$0, ValueBindingPatternSyntax.self, self.visit) + } + case .variableDecl: + return { + await self.visitImpl(&$0, VariableDeclSyntax.self, self.visit) + } + case .versionComponentList: + return { + await self.visitImpl(&$0, VersionComponentListSyntax.self, self.visit) + } + case .versionComponent: + return { + await self.visitImpl(&$0, VersionComponentSyntax.self, self.visit) + } + case .versionTuple: + return { + await self.visitImpl(&$0, VersionTupleSyntax.self, self.visit) + } + case .whereClause: + return { + await self.visitImpl(&$0, WhereClauseSyntax.self, self.visit) + } + case .whileStmt: + return { + await self.visitImpl(&$0, WhileStmtSyntax.self, self.visit) + } + case .wildcardPattern: + return { + await self.visitImpl(&$0, WildcardPatternSyntax.self, self.visit) + } + case .yieldStmt: + return { + await self.visitImpl(&$0, YieldStmtSyntax.self, self.visit) + } + case .yieldedExpressionList: + return { + await self.visitImpl(&$0, YieldedExpressionListSyntax.self, self.visit) + } + case .yieldedExpression: + return { + await self.visitImpl(&$0, YieldedExpressionSyntax.self, self.visit) + } + case .yieldedExpressionsClause: + return { + await self.visitImpl(&$0, YieldedExpressionsClauseSyntax.self, self.visit) + } + } + } + private func dispatchVisit(_ node: inout Syntax) async { + await visitationFunc(for: node)(&node) + } + #else + private func dispatchVisit(_ node: inout Syntax) async { + switch node.raw.kind { + case .token: + return await visitImpl(&node, TokenSyntax.self, visit) + case .accessorBlock: + return await visitImpl(&node, AccessorBlockSyntax.self, visit) + case .accessorDeclList: + return await visitImpl(&node, AccessorDeclListSyntax.self, visit) + case .accessorDecl: + return await visitImpl(&node, AccessorDeclSyntax.self, visit) + case .accessorEffectSpecifiers: + return await visitImpl(&node, AccessorEffectSpecifiersSyntax.self, visit) + case .accessorParameters: + return await visitImpl(&node, AccessorParametersSyntax.self, visit) + case .actorDecl: + return await visitImpl(&node, ActorDeclSyntax.self, visit) + case .arrayElementList: + return await visitImpl(&node, ArrayElementListSyntax.self, visit) + case .arrayElement: + return await visitImpl(&node, ArrayElementSyntax.self, visit) + case .arrayExpr: + return await visitImpl(&node, ArrayExprSyntax.self, visit) + case .arrayType: + return await visitImpl(&node, ArrayTypeSyntax.self, visit) + case .arrowExpr: + return await visitImpl(&node, ArrowExprSyntax.self, visit) + case .asExpr: + return await visitImpl(&node, AsExprSyntax.self, visit) + case .assignmentExpr: + return await visitImpl(&node, AssignmentExprSyntax.self, visit) + case .associatedTypeDecl: + return await visitImpl(&node, AssociatedTypeDeclSyntax.self, visit) + case .attributeList: + return await visitImpl(&node, AttributeListSyntax.self, visit) + case .attribute: + return await visitImpl(&node, AttributeSyntax.self, visit) + case .attributedType: + return await visitImpl(&node, AttributedTypeSyntax.self, visit) + case .availabilityArgumentList: + return await visitImpl(&node, AvailabilityArgumentListSyntax.self, visit) + case .availabilityArgument: + return await visitImpl(&node, AvailabilityArgumentSyntax.self, visit) + case .availabilityCondition: + return await visitImpl(&node, AvailabilityConditionSyntax.self, visit) + case .availabilityLabeledArgument: + return await visitImpl(&node, AvailabilityLabeledArgumentSyntax.self, visit) + case .awaitExpr: + return await visitImpl(&node, AwaitExprSyntax.self, visit) + case .backDeployedAttributeArguments: + return await visitImpl(&node, BackDeployedAttributeArgumentsSyntax.self, visit) + case .binaryOperatorExpr: + return await visitImpl(&node, BinaryOperatorExprSyntax.self, visit) + case .booleanLiteralExpr: + return await visitImpl(&node, BooleanLiteralExprSyntax.self, visit) + case .borrowExpr: + return await visitImpl(&node, BorrowExprSyntax.self, visit) + case .breakStmt: + return await visitImpl(&node, BreakStmtSyntax.self, visit) + case ._canImportExpr: + return await visitImpl(&node, _CanImportExprSyntax.self, visit) + case ._canImportVersionInfo: + return await visitImpl(&node, _CanImportVersionInfoSyntax.self, visit) + case .catchClauseList: + return await visitImpl(&node, CatchClauseListSyntax.self, visit) + case .catchClause: + return await visitImpl(&node, CatchClauseSyntax.self, visit) + case .catchItemList: + return await visitImpl(&node, CatchItemListSyntax.self, visit) + case .catchItem: + return await visitImpl(&node, CatchItemSyntax.self, visit) + case .classDecl: + return await visitImpl(&node, ClassDeclSyntax.self, visit) + case .classRestrictionType: + return await visitImpl(&node, ClassRestrictionTypeSyntax.self, visit) + case .closureCaptureClause: + return await visitImpl(&node, ClosureCaptureClauseSyntax.self, visit) + case .closureCaptureList: + return await visitImpl(&node, ClosureCaptureListSyntax.self, visit) + case .closureCaptureSpecifier: + return await visitImpl(&node, ClosureCaptureSpecifierSyntax.self, visit) + case .closureCapture: + return await visitImpl(&node, ClosureCaptureSyntax.self, visit) + case .closureExpr: + return await visitImpl(&node, ClosureExprSyntax.self, visit) + case .closureParameterClause: + return await visitImpl(&node, ClosureParameterClauseSyntax.self, visit) + case .closureParameterList: + return await visitImpl(&node, ClosureParameterListSyntax.self, visit) + case .closureParameter: + return await visitImpl(&node, ClosureParameterSyntax.self, visit) + case .closureShorthandParameterList: + return await visitImpl(&node, ClosureShorthandParameterListSyntax.self, visit) + case .closureShorthandParameter: + return await visitImpl(&node, ClosureShorthandParameterSyntax.self, visit) + case .closureSignature: + return await visitImpl(&node, ClosureSignatureSyntax.self, visit) + case .codeBlockItemList: + return await visitImpl(&node, CodeBlockItemListSyntax.self, visit) + case .codeBlockItem: + return await visitImpl(&node, CodeBlockItemSyntax.self, visit) + case .codeBlock: + return await visitImpl(&node, CodeBlockSyntax.self, visit) + case .compositionTypeElementList: + return await visitImpl(&node, CompositionTypeElementListSyntax.self, visit) + case .compositionTypeElement: + return await visitImpl(&node, CompositionTypeElementSyntax.self, visit) + case .compositionType: + return await visitImpl(&node, CompositionTypeSyntax.self, visit) + case .conditionElementList: + return await visitImpl(&node, ConditionElementListSyntax.self, visit) + case .conditionElement: + return await visitImpl(&node, ConditionElementSyntax.self, visit) + case .conformanceRequirement: + return await visitImpl(&node, ConformanceRequirementSyntax.self, visit) + case .consumeExpr: + return await visitImpl(&node, ConsumeExprSyntax.self, visit) + case .continueStmt: + return await visitImpl(&node, ContinueStmtSyntax.self, visit) + case .conventionAttributeArguments: + return await visitImpl(&node, ConventionAttributeArgumentsSyntax.self, visit) + case .conventionWitnessMethodAttributeArguments: + return await visitImpl(&node, ConventionWitnessMethodAttributeArgumentsSyntax.self, visit) + case .copyExpr: + return await visitImpl(&node, CopyExprSyntax.self, visit) + case .declModifierDetail: + return await visitImpl(&node, DeclModifierDetailSyntax.self, visit) + case .declModifierList: + return await visitImpl(&node, DeclModifierListSyntax.self, visit) + case .declModifier: + return await visitImpl(&node, DeclModifierSyntax.self, visit) + case .declNameArgumentList: + return await visitImpl(&node, DeclNameArgumentListSyntax.self, visit) + case .declNameArgument: + return await visitImpl(&node, DeclNameArgumentSyntax.self, visit) + case .declNameArguments: + return await visitImpl(&node, DeclNameArgumentsSyntax.self, visit) + case .declReferenceExpr: + return await visitImpl(&node, DeclReferenceExprSyntax.self, visit) + case .deferStmt: + return await visitImpl(&node, DeferStmtSyntax.self, visit) + case .deinitializerDecl: + return await visitImpl(&node, DeinitializerDeclSyntax.self, visit) + case .deinitializerEffectSpecifiers: + return await visitImpl(&node, DeinitializerEffectSpecifiersSyntax.self, visit) + case .derivativeAttributeArguments: + return await visitImpl(&node, DerivativeAttributeArgumentsSyntax.self, visit) + case .designatedTypeList: + return await visitImpl(&node, DesignatedTypeListSyntax.self, visit) + case .designatedType: + return await visitImpl(&node, DesignatedTypeSyntax.self, visit) + case .dictionaryElementList: + return await visitImpl(&node, DictionaryElementListSyntax.self, visit) + case .dictionaryElement: + return await visitImpl(&node, DictionaryElementSyntax.self, visit) + case .dictionaryExpr: + return await visitImpl(&node, DictionaryExprSyntax.self, visit) + case .dictionaryType: + return await visitImpl(&node, DictionaryTypeSyntax.self, visit) + case .differentiabilityArgumentList: + return await visitImpl(&node, DifferentiabilityArgumentListSyntax.self, visit) + case .differentiabilityArgument: + return await visitImpl(&node, DifferentiabilityArgumentSyntax.self, visit) + case .differentiabilityArguments: + return await visitImpl(&node, DifferentiabilityArgumentsSyntax.self, visit) + case .differentiabilityWithRespectToArgument: + return await visitImpl(&node, DifferentiabilityWithRespectToArgumentSyntax.self, visit) + case .differentiableAttributeArguments: + return await visitImpl(&node, DifferentiableAttributeArgumentsSyntax.self, visit) + case .discardAssignmentExpr: + return await visitImpl(&node, DiscardAssignmentExprSyntax.self, visit) + case .discardStmt: + return await visitImpl(&node, DiscardStmtSyntax.self, visit) + case .doExpr: + return await visitImpl(&node, DoExprSyntax.self, visit) + case .doStmt: + return await visitImpl(&node, DoStmtSyntax.self, visit) + case .documentationAttributeArgumentList: + return await visitImpl(&node, DocumentationAttributeArgumentListSyntax.self, visit) + case .documentationAttributeArgument: + return await visitImpl(&node, DocumentationAttributeArgumentSyntax.self, visit) + case .dynamicReplacementAttributeArguments: + return await visitImpl(&node, DynamicReplacementAttributeArgumentsSyntax.self, visit) + case .editorPlaceholderDecl: + return await visitImpl(&node, EditorPlaceholderDeclSyntax.self, visit) + case .editorPlaceholderExpr: + return await visitImpl(&node, EditorPlaceholderExprSyntax.self, visit) + case .effectsAttributeArgumentList: + return await visitImpl(&node, EffectsAttributeArgumentListSyntax.self, visit) + case .enumCaseDecl: + return await visitImpl(&node, EnumCaseDeclSyntax.self, visit) + case .enumCaseElementList: + return await visitImpl(&node, EnumCaseElementListSyntax.self, visit) + case .enumCaseElement: + return await visitImpl(&node, EnumCaseElementSyntax.self, visit) + case .enumCaseParameterClause: + return await visitImpl(&node, EnumCaseParameterClauseSyntax.self, visit) + case .enumCaseParameterList: + return await visitImpl(&node, EnumCaseParameterListSyntax.self, visit) + case .enumCaseParameter: + return await visitImpl(&node, EnumCaseParameterSyntax.self, visit) + case .enumDecl: + return await visitImpl(&node, EnumDeclSyntax.self, visit) + case .exposeAttributeArguments: + return await visitImpl(&node, ExposeAttributeArgumentsSyntax.self, visit) + case .exprList: + return await visitImpl(&node, ExprListSyntax.self, visit) + case .expressionPattern: + return await visitImpl(&node, ExpressionPatternSyntax.self, visit) + case .expressionSegment: + return await visitImpl(&node, ExpressionSegmentSyntax.self, visit) + case .expressionStmt: + return await visitImpl(&node, ExpressionStmtSyntax.self, visit) + case .extensionDecl: + return await visitImpl(&node, ExtensionDeclSyntax.self, visit) + case .fallThroughStmt: + return await visitImpl(&node, FallThroughStmtSyntax.self, visit) + case .floatLiteralExpr: + return await visitImpl(&node, FloatLiteralExprSyntax.self, visit) + case .forStmt: + return await visitImpl(&node, ForStmtSyntax.self, visit) + case .forceUnwrapExpr: + return await visitImpl(&node, ForceUnwrapExprSyntax.self, visit) + case .functionCallExpr: + return await visitImpl(&node, FunctionCallExprSyntax.self, visit) + case .functionDecl: + return await visitImpl(&node, FunctionDeclSyntax.self, visit) + case .functionEffectSpecifiers: + return await visitImpl(&node, FunctionEffectSpecifiersSyntax.self, visit) + case .functionParameterClause: + return await visitImpl(&node, FunctionParameterClauseSyntax.self, visit) + case .functionParameterList: + return await visitImpl(&node, FunctionParameterListSyntax.self, visit) + case .functionParameter: + return await visitImpl(&node, FunctionParameterSyntax.self, visit) + case .functionSignature: + return await visitImpl(&node, FunctionSignatureSyntax.self, visit) + case .functionType: + return await visitImpl(&node, FunctionTypeSyntax.self, visit) + case .genericArgumentClause: + return await visitImpl(&node, GenericArgumentClauseSyntax.self, visit) + case .genericArgumentList: + return await visitImpl(&node, GenericArgumentListSyntax.self, visit) + case .genericArgument: + return await visitImpl(&node, GenericArgumentSyntax.self, visit) + case .genericParameterClause: + return await visitImpl(&node, GenericParameterClauseSyntax.self, visit) + case .genericParameterList: + return await visitImpl(&node, GenericParameterListSyntax.self, visit) + case .genericParameter: + return await visitImpl(&node, GenericParameterSyntax.self, visit) + case .genericRequirementList: + return await visitImpl(&node, GenericRequirementListSyntax.self, visit) + case .genericRequirement: + return await visitImpl(&node, GenericRequirementSyntax.self, visit) + case .genericSpecializationExpr: + return await visitImpl(&node, GenericSpecializationExprSyntax.self, visit) + case .genericWhereClause: + return await visitImpl(&node, GenericWhereClauseSyntax.self, visit) + case .guardStmt: + return await visitImpl(&node, GuardStmtSyntax.self, visit) + case .identifierPattern: + return await visitImpl(&node, IdentifierPatternSyntax.self, visit) + case .identifierType: + return await visitImpl(&node, IdentifierTypeSyntax.self, visit) + case .ifConfigClauseList: + return await visitImpl(&node, IfConfigClauseListSyntax.self, visit) + case .ifConfigClause: + return await visitImpl(&node, IfConfigClauseSyntax.self, visit) + case .ifConfigDecl: + return await visitImpl(&node, IfConfigDeclSyntax.self, visit) + case .ifExpr: + return await visitImpl(&node, IfExprSyntax.self, visit) + case .implementsAttributeArguments: + return await visitImpl(&node, ImplementsAttributeArgumentsSyntax.self, visit) + case .implicitlyUnwrappedOptionalType: + return await visitImpl(&node, ImplicitlyUnwrappedOptionalTypeSyntax.self, visit) + case .importDecl: + return await visitImpl(&node, ImportDeclSyntax.self, visit) + case .importPathComponentList: + return await visitImpl(&node, ImportPathComponentListSyntax.self, visit) + case .importPathComponent: + return await visitImpl(&node, ImportPathComponentSyntax.self, visit) + case .inOutExpr: + return await visitImpl(&node, InOutExprSyntax.self, visit) + case .infixOperatorExpr: + return await visitImpl(&node, InfixOperatorExprSyntax.self, visit) + case .inheritanceClause: + return await visitImpl(&node, InheritanceClauseSyntax.self, visit) + case .inheritedTypeList: + return await visitImpl(&node, InheritedTypeListSyntax.self, visit) + case .inheritedType: + return await visitImpl(&node, InheritedTypeSyntax.self, visit) + case .initializerClause: + return await visitImpl(&node, InitializerClauseSyntax.self, visit) + case .initializerDecl: + return await visitImpl(&node, InitializerDeclSyntax.self, visit) + case .integerLiteralExpr: + return await visitImpl(&node, IntegerLiteralExprSyntax.self, visit) + case .isExpr: + return await visitImpl(&node, IsExprSyntax.self, visit) + case .isTypePattern: + return await visitImpl(&node, IsTypePatternSyntax.self, visit) + case .keyPathComponentList: + return await visitImpl(&node, KeyPathComponentListSyntax.self, visit) + case .keyPathComponent: + return await visitImpl(&node, KeyPathComponentSyntax.self, visit) + case .keyPathExpr: + return await visitImpl(&node, KeyPathExprSyntax.self, visit) + case .keyPathOptionalComponent: + return await visitImpl(&node, KeyPathOptionalComponentSyntax.self, visit) + case .keyPathPropertyComponent: + return await visitImpl(&node, KeyPathPropertyComponentSyntax.self, visit) + case .keyPathSubscriptComponent: + return await visitImpl(&node, KeyPathSubscriptComponentSyntax.self, visit) + case .labeledExprList: + return await visitImpl(&node, LabeledExprListSyntax.self, visit) + case .labeledExpr: + return await visitImpl(&node, LabeledExprSyntax.self, visit) + case .labeledSpecializeArgument: + return await visitImpl(&node, LabeledSpecializeArgumentSyntax.self, visit) + case .labeledStmt: + return await visitImpl(&node, LabeledStmtSyntax.self, visit) + case .layoutRequirement: + return await visitImpl(&node, LayoutRequirementSyntax.self, visit) + case .lifetimeSpecifierArgumentList: + return await visitImpl(&node, LifetimeSpecifierArgumentListSyntax.self, visit) + case .lifetimeSpecifierArgument: + return await visitImpl(&node, LifetimeSpecifierArgumentSyntax.self, visit) + case .lifetimeTypeSpecifier: + return await visitImpl(&node, LifetimeTypeSpecifierSyntax.self, visit) + case .macroDecl: + return await visitImpl(&node, MacroDeclSyntax.self, visit) + case .macroExpansionDecl: + return await visitImpl(&node, MacroExpansionDeclSyntax.self, visit) + case .macroExpansionExpr: + return await visitImpl(&node, MacroExpansionExprSyntax.self, visit) + case .matchingPatternCondition: + return await visitImpl(&node, MatchingPatternConditionSyntax.self, visit) + case .memberAccessExpr: + return await visitImpl(&node, MemberAccessExprSyntax.self, visit) + case .memberBlockItemList: + return await visitImpl(&node, MemberBlockItemListSyntax.self, visit) + case .memberBlockItem: + return await visitImpl(&node, MemberBlockItemSyntax.self, visit) + case .memberBlock: + return await visitImpl(&node, MemberBlockSyntax.self, visit) + case .memberType: + return await visitImpl(&node, MemberTypeSyntax.self, visit) + case .metatypeType: + return await visitImpl(&node, MetatypeTypeSyntax.self, visit) + case .missingDecl: + return await visitImpl(&node, MissingDeclSyntax.self, visit) + case .missingExpr: + return await visitImpl(&node, MissingExprSyntax.self, visit) + case .missingPattern: + return await visitImpl(&node, MissingPatternSyntax.self, visit) + case .missingStmt: + return await visitImpl(&node, MissingStmtSyntax.self, visit) + case .missing: + return await visitImpl(&node, MissingSyntax.self, visit) + case .missingType: + return await visitImpl(&node, MissingTypeSyntax.self, visit) + case .multipleTrailingClosureElementList: + return await visitImpl(&node, MultipleTrailingClosureElementListSyntax.self, visit) + case .multipleTrailingClosureElement: + return await visitImpl(&node, MultipleTrailingClosureElementSyntax.self, visit) + case .namedOpaqueReturnType: + return await visitImpl(&node, NamedOpaqueReturnTypeSyntax.self, visit) + case .nilLiteralExpr: + return await visitImpl(&node, NilLiteralExprSyntax.self, visit) + case .objCSelectorPieceList: + return await visitImpl(&node, ObjCSelectorPieceListSyntax.self, visit) + case .objCSelectorPiece: + return await visitImpl(&node, ObjCSelectorPieceSyntax.self, visit) + case .opaqueReturnTypeOfAttributeArguments: + return await visitImpl(&node, OpaqueReturnTypeOfAttributeArgumentsSyntax.self, visit) + case .operatorDecl: + return await visitImpl(&node, OperatorDeclSyntax.self, visit) + case .operatorPrecedenceAndTypes: + return await visitImpl(&node, OperatorPrecedenceAndTypesSyntax.self, visit) + case .optionalBindingCondition: + return await visitImpl(&node, OptionalBindingConditionSyntax.self, visit) + case .optionalChainingExpr: + return await visitImpl(&node, OptionalChainingExprSyntax.self, visit) + case .optionalType: + return await visitImpl(&node, OptionalTypeSyntax.self, visit) + case .originallyDefinedInAttributeArguments: + return await visitImpl(&node, OriginallyDefinedInAttributeArgumentsSyntax.self, visit) + case .packElementExpr: + return await visitImpl(&node, PackElementExprSyntax.self, visit) + case .packElementType: + return await visitImpl(&node, PackElementTypeSyntax.self, visit) + case .packExpansionExpr: + return await visitImpl(&node, PackExpansionExprSyntax.self, visit) + case .packExpansionType: + return await visitImpl(&node, PackExpansionTypeSyntax.self, visit) + case .patternBindingList: + return await visitImpl(&node, PatternBindingListSyntax.self, visit) + case .patternBinding: + return await visitImpl(&node, PatternBindingSyntax.self, visit) + case .patternExpr: + return await visitImpl(&node, PatternExprSyntax.self, visit) + case .platformVersionItemList: + return await visitImpl(&node, PlatformVersionItemListSyntax.self, visit) + case .platformVersionItem: + return await visitImpl(&node, PlatformVersionItemSyntax.self, visit) + case .platformVersion: + return await visitImpl(&node, PlatformVersionSyntax.self, visit) + case .postfixIfConfigExpr: + return await visitImpl(&node, PostfixIfConfigExprSyntax.self, visit) + case .postfixOperatorExpr: + return await visitImpl(&node, PostfixOperatorExprSyntax.self, visit) + case .poundSourceLocationArguments: + return await visitImpl(&node, PoundSourceLocationArgumentsSyntax.self, visit) + case .poundSourceLocation: + return await visitImpl(&node, PoundSourceLocationSyntax.self, visit) + case .precedenceGroupAssignment: + return await visitImpl(&node, PrecedenceGroupAssignmentSyntax.self, visit) + case .precedenceGroupAssociativity: + return await visitImpl(&node, PrecedenceGroupAssociativitySyntax.self, visit) + case .precedenceGroupAttributeList: + return await visitImpl(&node, PrecedenceGroupAttributeListSyntax.self, visit) + case .precedenceGroupDecl: + return await visitImpl(&node, PrecedenceGroupDeclSyntax.self, visit) + case .precedenceGroupNameList: + return await visitImpl(&node, PrecedenceGroupNameListSyntax.self, visit) + case .precedenceGroupName: + return await visitImpl(&node, PrecedenceGroupNameSyntax.self, visit) + case .precedenceGroupRelation: + return await visitImpl(&node, PrecedenceGroupRelationSyntax.self, visit) + case .prefixOperatorExpr: + return await visitImpl(&node, PrefixOperatorExprSyntax.self, visit) + case .primaryAssociatedTypeClause: + return await visitImpl(&node, PrimaryAssociatedTypeClauseSyntax.self, visit) + case .primaryAssociatedTypeList: + return await visitImpl(&node, PrimaryAssociatedTypeListSyntax.self, visit) + case .primaryAssociatedType: + return await visitImpl(&node, PrimaryAssociatedTypeSyntax.self, visit) + case .protocolDecl: + return await visitImpl(&node, ProtocolDeclSyntax.self, visit) + case .regexLiteralExpr: + return await visitImpl(&node, RegexLiteralExprSyntax.self, visit) + case .repeatStmt: + return await visitImpl(&node, RepeatStmtSyntax.self, visit) + case .returnClause: + return await visitImpl(&node, ReturnClauseSyntax.self, visit) + case .returnStmt: + return await visitImpl(&node, ReturnStmtSyntax.self, visit) + case .sameTypeRequirement: + return await visitImpl(&node, SameTypeRequirementSyntax.self, visit) + case .sequenceExpr: + return await visitImpl(&node, SequenceExprSyntax.self, visit) + case .simpleStringLiteralExpr: + return await visitImpl(&node, SimpleStringLiteralExprSyntax.self, visit) + case .simpleStringLiteralSegmentList: + return await visitImpl(&node, SimpleStringLiteralSegmentListSyntax.self, visit) + case .simpleTypeSpecifier: + return await visitImpl(&node, SimpleTypeSpecifierSyntax.self, visit) + case .someOrAnyType: + return await visitImpl(&node, SomeOrAnyTypeSyntax.self, visit) + case .sourceFile: + return await visitImpl(&node, SourceFileSyntax.self, visit) + case .specializeAttributeArgumentList: + return await visitImpl(&node, SpecializeAttributeArgumentListSyntax.self, visit) + case .specializeAvailabilityArgument: + return await visitImpl(&node, SpecializeAvailabilityArgumentSyntax.self, visit) + case .specializeTargetFunctionArgument: + return await visitImpl(&node, SpecializeTargetFunctionArgumentSyntax.self, visit) + case .stringLiteralExpr: + return await visitImpl(&node, StringLiteralExprSyntax.self, visit) + case .stringLiteralSegmentList: + return await visitImpl(&node, StringLiteralSegmentListSyntax.self, visit) + case .stringSegment: + return await visitImpl(&node, StringSegmentSyntax.self, visit) + case .structDecl: + return await visitImpl(&node, StructDeclSyntax.self, visit) + case .subscriptCallExpr: + return await visitImpl(&node, SubscriptCallExprSyntax.self, visit) + case .subscriptDecl: + return await visitImpl(&node, SubscriptDeclSyntax.self, visit) + case .superExpr: + return await visitImpl(&node, SuperExprSyntax.self, visit) + case .suppressedType: + return await visitImpl(&node, SuppressedTypeSyntax.self, visit) + case .switchCaseItemList: + return await visitImpl(&node, SwitchCaseItemListSyntax.self, visit) + case .switchCaseItem: + return await visitImpl(&node, SwitchCaseItemSyntax.self, visit) + case .switchCaseLabel: + return await visitImpl(&node, SwitchCaseLabelSyntax.self, visit) + case .switchCaseList: + return await visitImpl(&node, SwitchCaseListSyntax.self, visit) + case .switchCase: + return await visitImpl(&node, SwitchCaseSyntax.self, visit) + case .switchDefaultLabel: + return await visitImpl(&node, SwitchDefaultLabelSyntax.self, visit) + case .switchExpr: + return await visitImpl(&node, SwitchExprSyntax.self, visit) + case .ternaryExpr: + return await visitImpl(&node, TernaryExprSyntax.self, visit) + case .thenStmt: + return await visitImpl(&node, ThenStmtSyntax.self, visit) + case .throwStmt: + return await visitImpl(&node, ThrowStmtSyntax.self, visit) + case .throwsClause: + return await visitImpl(&node, ThrowsClauseSyntax.self, visit) + case .tryExpr: + return await visitImpl(&node, TryExprSyntax.self, visit) + case .tupleExpr: + return await visitImpl(&node, TupleExprSyntax.self, visit) + case .tuplePatternElementList: + return await visitImpl(&node, TuplePatternElementListSyntax.self, visit) + case .tuplePatternElement: + return await visitImpl(&node, TuplePatternElementSyntax.self, visit) + case .tuplePattern: + return await visitImpl(&node, TuplePatternSyntax.self, visit) + case .tupleTypeElementList: + return await visitImpl(&node, TupleTypeElementListSyntax.self, visit) + case .tupleTypeElement: + return await visitImpl(&node, TupleTypeElementSyntax.self, visit) + case .tupleType: + return await visitImpl(&node, TupleTypeSyntax.self, visit) + case .typeAliasDecl: + return await visitImpl(&node, TypeAliasDeclSyntax.self, visit) + case .typeAnnotation: + return await visitImpl(&node, TypeAnnotationSyntax.self, visit) + case .typeEffectSpecifiers: + return await visitImpl(&node, TypeEffectSpecifiersSyntax.self, visit) + case .typeExpr: + return await visitImpl(&node, TypeExprSyntax.self, visit) + case .typeInitializerClause: + return await visitImpl(&node, TypeInitializerClauseSyntax.self, visit) + case .typeSpecifierList: + return await visitImpl(&node, TypeSpecifierListSyntax.self, visit) + case .unavailableFromAsyncAttributeArguments: + return await visitImpl(&node, UnavailableFromAsyncAttributeArgumentsSyntax.self, visit) + case .underscorePrivateAttributeArguments: + return await visitImpl(&node, UnderscorePrivateAttributeArgumentsSyntax.self, visit) + case .unexpectedNodes: + return await visitImpl(&node, UnexpectedNodesSyntax.self, visit) + case .unresolvedAsExpr: + return await visitImpl(&node, UnresolvedAsExprSyntax.self, visit) + case .unresolvedIsExpr: + return await visitImpl(&node, UnresolvedIsExprSyntax.self, visit) + case .unresolvedTernaryExpr: + return await visitImpl(&node, UnresolvedTernaryExprSyntax.self, visit) + case .valueBindingPattern: + return await visitImpl(&node, ValueBindingPatternSyntax.self, visit) + case .variableDecl: + return await visitImpl(&node, VariableDeclSyntax.self, visit) + case .versionComponentList: + return await visitImpl(&node, VersionComponentListSyntax.self, visit) + case .versionComponent: + return await visitImpl(&node, VersionComponentSyntax.self, visit) + case .versionTuple: + return await visitImpl(&node, VersionTupleSyntax.self, visit) + case .whereClause: + return await visitImpl(&node, WhereClauseSyntax.self, visit) + case .whileStmt: + return await visitImpl(&node, WhileStmtSyntax.self, visit) + case .wildcardPattern: + return await visitImpl(&node, WildcardPatternSyntax.self, visit) + case .yieldStmt: + return await visitImpl(&node, YieldStmtSyntax.self, visit) + case .yieldedExpressionList: + return await visitImpl(&node, YieldedExpressionListSyntax.self, visit) + case .yieldedExpression: + return await visitImpl(&node, YieldedExpressionSyntax.self, visit) + case .yieldedExpressionsClause: + return await visitImpl(&node, YieldedExpressionsClauseSyntax.self, visit) + } + } + #endif + + private func visitChildren(_ node: Syntax) async -> Syntax { + // Walk over all children of this node and rewrite them. Don't store any + // rewritten nodes until the first non-`nil` value is encountered. When this + // happens, retrieve all previous syntax nodes from the parent node to + // initialize the new layout. Once we know that we have to rewrite the + // layout, we need to collect all further children, regardless of whether + // they are rewritten or not. + + // newLayout is nil until the first child node is rewritten and rewritten + // nodes are being collected. + var newLayout: UnsafeMutableBufferPointer = .init(start: nil, count: 0) + + // Keep 'SyntaxArena' of rewritten nodes alive until they are wrapped + // with 'Syntax' + var rewrittens: ContiguousArray = [] + + for case let (child?, info) in RawSyntaxChildren(node) where viewMode.shouldTraverse(node: child) { + + // Build the Syntax node to rewrite + var childNode = nodeFactory.create(parent: node, raw: child, absoluteInfo: info) + + await dispatchVisit(&childNode) + if childNode.raw.id != child.id { + // The node was rewritten, let's handle it + + if newLayout.baseAddress == nil { + // We have not yet collected any previous rewritten nodes. Initialize + // the new layout with the previous nodes of the parent. + newLayout = .allocate(capacity: node.raw.layoutView!.children.count) + _ = newLayout.initialize(fromContentsOf: node.raw.layoutView!.children) + } + + // Update the rewritten child. + newLayout[Int(info.indexInParent)] = childNode.raw + // Retain the syntax arena of the new node until it's wrapped with Syntax node. + rewrittens.append(childNode.raw.arenaReference.retained) + } + + // Recycle 'childNode.info' + nodeFactory.dispose(&childNode) + } + + if newLayout.baseAddress != nil { + // A child node was rewritten. Build the updated node. + + let arena = self.arena ?? SyntaxArena() + let newRaw = node.raw.layoutView!.replacingLayout(with: newLayout, arena: arena) + newLayout.deinitialize() + newLayout.deallocate() + // 'withExtendedLifetime' to keep 'SyntaxArena's of them alive until here. + return withExtendedLifetime(rewrittens) { + Syntax(raw: newRaw, rawNodeArena: arena) + } + } else { + // No child node was rewritten. So no need to change this node as well. + return node + } + } +} diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index a480ba73435..0f28ff048bf 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -2157,7 +2157,11 @@ open class SyntaxRewriter { ) { let origNode = node visitPre(origNode) - node = visitAny(origNode) ?? Syntax(visit(origNode.cast(NodeType.self))) + node = if let newNode = visitAny(origNode) { + newNode + } else { + Syntax(visit(origNode.cast(NodeType.self))) + } visitPost(origNode) }