diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift index 3753ae54a6e..eda6ae8c9b5 100644 --- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift +++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift @@ -60,53 +60,44 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { \(node.generateInitializerDeclHeader()) """ ) { - let parameters = ClosureParameterListSyntax { - for child in node.children { - ClosureParameterSyntax(firstName: child.varOrCaseName.backtickedIfNeeded) - } - } - let closureSignature = ClosureSignatureSyntax( parameterClause: .parameterClause( ClosureParameterClauseSyntax( parameters: ClosureParameterListSyntax { - ClosureParameterSyntax(firstName: .identifier("arena")) - ClosureParameterSyntax(firstName: .wildcardToken()) + ClosureParameterSyntax(firstName: "arena") } ) ) ) - let layoutList = ArrayExprSyntax { - for child in node.children { - ArrayElementSyntax( - expression: MemberAccessExprSyntax( - base: child.buildableType.optionalChained( - expr: ExprSyntax("\(child.varOrCaseName.backtickedIfNeeded)") - ), - period: .periodToken(), - name: "raw" - ) - ) - } - } + VariableDeclSyntax( + .let, + name: "nodes", + type: TypeAnnotationSyntax(type: TypeSyntax("[Syntax?]")), + initializer: InitializerClauseSyntax( + value: ArrayExprSyntax { + for child in node.children { + ArrayElementSyntax(expression: ExprSyntax("Syntax(\(child.varOrCaseName.backtickedIfNeeded))")) + } + } + ) + ) let initializer = FunctionCallExprSyntax( calledExpression: ExprSyntax("withExtendedLifetime"), leftParen: .leftParenToken(), arguments: LabeledExprListSyntax { - LabeledExprSyntax(expression: ExprSyntax("(SyntaxArena(), (\(parameters)))")) + LabeledExprSyntax(expression: ExprSyntax("SyntaxArena()")) }, rightParen: .rightParenToken(), trailingClosure: ClosureExprSyntax(signature: closureSignature) { if node.children.isEmpty { DeclSyntax("let raw = RawSyntax.makeEmptyLayout(kind: SyntaxKind.\(node.varOrCaseName), arena: arena)") } else { - DeclSyntax("let layout: [RawSyntax?] = \(layoutList)") DeclSyntax( """ let raw = RawSyntax.makeLayout( kind: SyntaxKind.\(node.varOrCaseName), - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -128,6 +119,8 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { operator: ExprSyntax(AssignmentExprSyntax()), rightOperand: initializer ) + + ExprSyntax("Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes))") } for (index, child) in node.children.enumerated() { @@ -188,7 +181,7 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax { collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.\(childNode.varOrCaseName), - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild(at: \(raw: index), with: collection, rawNodeArena: arena, allocationArena: arena) diff --git a/Release Notes/601.md b/Release Notes/601.md index 0aa91b991d7..a12204d6a71 100644 --- a/Release Notes/601.md +++ b/Release Notes/601.md @@ -6,7 +6,7 @@ - Description: Allows retrieving the represented literal value when valid. - Issue: https://github.com/apple/swift-syntax/issues/405 - Pull Request: https://github.com/apple/swift-syntax/pull/2605 - + - `SyntaxProtocol` now has a method `ancestorOrSelf`. - Description: Returns the node or the first ancestor that satisfies `condition`. - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2696 @@ -19,6 +19,11 @@ - Description: This new library provides facilities for evaluating `#if` conditions and determining which regions of a syntax tree are active according to a given build configuration. - Pull Request: https://github.com/swiftlang/swift-syntax/pull/1816 +- `SyntaxProtocol.tracked` / `SyntaxProtocol.originalNode(in:)` + - Description: `tracked` enables node tracking of a tree. For every tree derived from a tracked tree, `originalNode(in:)` returns the original node in the tracked tree. This allows clients to e.g. get the original location of a node in a source file after a tree has been modified. + - Issue: rdar://112679655 + - Pull Request: https://github.com/apple/swift-syntax/pull/2118 + ## API Behavior Changes - `SyntaxProtocol.trimmed` detaches the node @@ -38,7 +43,7 @@ - Description: Allows retrieving the radix value from the `literal.text`. - Issue: https://github.com/apple/swift-syntax/issues/405 - Pull Request: https://github.com/apple/swift-syntax/pull/2605 - + - `FixIt.Change` gained a new case `replaceChild(data:)`. - Description: The new case covers the replacement of a child node with another node. - Issue: https://github.com/swiftlang/swift-syntax/issues/2205 diff --git a/Sources/SwiftSyntax/AbsoluteRawSyntax.swift b/Sources/SwiftSyntax/AbsoluteRawSyntax.swift index a3f5aec25e7..453d799c673 100644 --- a/Sources/SwiftSyntax/AbsoluteRawSyntax.swift +++ b/Sources/SwiftSyntax/AbsoluteRawSyntax.swift @@ -39,7 +39,7 @@ struct AbsoluteRawSyntax: Sendable { return nil } - func replacingSelf(_ newRaw: RawSyntax, newRootId: UInt) -> AbsoluteRawSyntax { + func replacingSelf(_ newRaw: RawSyntax, newRootId: RootID) -> AbsoluteRawSyntax { let nodeId = SyntaxIdentifier(rootId: newRootId, indexInTree: info.nodeId.indexInTree) let newInfo = AbsoluteSyntaxInfo(position: info.position, nodeId: nodeId) return .init(raw: newRaw, info: newInfo) diff --git a/Sources/SwiftSyntax/CMakeLists.txt b/Sources/SwiftSyntax/CMakeLists.txt index 617183bab6f..c555a9558b0 100644 --- a/Sources/SwiftSyntax/CMakeLists.txt +++ b/Sources/SwiftSyntax/CMakeLists.txt @@ -34,6 +34,7 @@ add_swift_syntax_library(SwiftSyntax SyntaxNodeStructure.swift SyntaxProtocol.swift SyntaxText.swift + SyntaxTracking.swift SyntaxTreeViewMode.swift TokenDiagnostic.swift TokenSequence.swift diff --git a/Sources/SwiftSyntax/Raw/RawSyntax.swift b/Sources/SwiftSyntax/Raw/RawSyntax.swift index b0f51cd55a2..be1f396fc73 100644 --- a/Sources/SwiftSyntax/Raw/RawSyntax.swift +++ b/Sources/SwiftSyntax/Raw/RawSyntax.swift @@ -817,13 +817,13 @@ extension RawSyntax { static func makeLayout( kind: SyntaxKind, - from collection: some Collection, + from collection: some Collection, arena: __shared SyntaxArena, leadingTrivia: Trivia? = nil, trailingTrivia: Trivia? = nil ) -> RawSyntax { if leadingTrivia != nil || trailingTrivia != nil { - var layout = Array(collection) + var layout = collection.map { $0?.raw } if let leadingTrivia = leadingTrivia, // Find the index of the first non-empty node so we can attach the trivia to it. let idx = layout.firstIndex(where: { $0 != nil && ($0!.isToken || $0!.totalNodes > 1) }) @@ -842,11 +842,13 @@ extension RawSyntax { arena: arena ) } - return .makeLayout(kind: kind, from: layout, arena: arena) + return .makeLayout(kind: kind, uninitializedCount: collection.count, arena: arena) { + _ = $0.initialize(from: layout) + } } return .makeLayout(kind: kind, uninitializedCount: collection.count, arena: arena) { - _ = $0.initialize(from: collection) + _ = $0.initialize(from: collection.lazy.map { $0?.raw }) } } } diff --git a/Sources/SwiftSyntax/Syntax.swift b/Sources/SwiftSyntax/Syntax.swift index f6051f85ec5..23d1eae2768 100644 --- a/Sources/SwiftSyntax/Syntax.swift +++ b/Sources/SwiftSyntax/Syntax.swift @@ -23,10 +23,47 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { final class Info: @unchecked Sendable { // For root node. struct Root: Sendable { - private var arena: RetainedSyntaxArena + private let arena: RetainedSyntaxArena + var syntaxTracking: SyntaxTracking? - init(arena: RetainedSyntaxArena) { + init(arena: RetainedSyntaxArena, syntaxTracking: SyntaxTracking?) { self.arena = arena + self.syntaxTracking = syntaxTracking + } + } + + /// Class that owns a `Root`, is responsible for keeping it alive and also offers an unsafe pointer way to + /// access it. + /// + /// This way, the root node of a tree can own the root info and all other nodes in the tree can have an unsafe + /// pointer reference to the root info, which doesn't involve ref counting. + final class RefCountedRoot: Sendable { + /// `nonisolated(unsafe)` if fine because there are only two ways this gets accessed: + /// - `pointer`: Here we reference `value` via inout to get a pointer to `Root` but the pointer is not mutable + /// so no mutation happens here + #if swift(>=6) + private nonisolated(unsafe) var value: Root + #else + private var value: Root + #endif + + fileprivate init(_ value: Root) { + self.value = value + } + + fileprivate var pointer: UnsafePointer { + return withUnsafePointer(to: &value) { $0 } + } + + /// Get a reference to the root info which can be mutated. + /// + /// - Warning: This must only be used if the caller is guaranteed to have exclusive access to the tree and no + /// concurrent accesses can happen. Effectively, this can only be guaranteed if the tree has just been created, + /// and it hasn't been returned to any function which might concurrently access it. + /// In practice, this should only be used to set the `SyntaxTracking` on the root after a new tree has been + /// created (eg. by replacing a child in an existing tree) but before that new tree is returned to the client. + fileprivate var mutablePointer: UnsafeMutablePointer { + return withUnsafeMutablePointer(to: &value) { $0 } } } @@ -34,10 +71,23 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { struct NonRoot: Sendable { var parent: Syntax var absoluteInfo: AbsoluteSyntaxInfo + // `nonisolated(unsafe)` is fine because `Root` is owned by `RefCountedRoot` and `RefCountedRoot` guarantees that + // `Root` is not changing after the tree has been created. + #if swift(>=6) + nonisolated(unsafe) var rootInfo: UnsafePointer + #else + var rootInfo: UnsafePointer + #endif + + init(parent: Syntax, absoluteInfo: AbsoluteSyntaxInfo, rootInfo: UnsafePointer) { + self.parent = parent + self.absoluteInfo = absoluteInfo + self.rootInfo = rootInfo + } } enum InfoImpl: Sendable { - case root(Root) + case root(RefCountedRoot) case nonRoot(NonRoot) } @@ -67,13 +117,27 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { var info: Info! let raw: RawSyntax - private var rootInfo: Info.Root { + var rootInfo: UnsafePointer { switch info.info! { - case .root(let info): return info + case .root(let info): return info.pointer case .nonRoot(let info): return info.parent.rootInfo } } + /// Get a reference to the root info which can be mutated. + /// + /// - Warning: This must only be used if the caller is guaranteed to have exclusive access to the tree and no + /// concurrent accesses can happen. Effectively, this can only be guaranteed if the tree has just been created, + /// and it hasn't been returned to any function which might concurrently access it. + /// In practice, this should only be used to set the `SyntaxTracking` on the root after a new tree has been + /// created (eg. by replacing a child in an existing tree) but before that new tree is returned to the client. + var mutableRootInfo: UnsafeMutablePointer { + switch info.info! { + case .root(let info): return info.mutablePointer + case .nonRoot(let info): return info.parent.mutableRootInfo + } + } + private var nonRootInfo: Info.NonRoot? { switch info.info! { case .root(_): return nil @@ -108,6 +172,20 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { absoluteInfo.nodeId } + var syntaxTracking: SyntaxTracking? { + rootInfo.pointee.syntaxTracking + } + + /// Set the translation ranges of the entire tree. + /// + /// - Warning: This must only be used if the caller is guaranteed to have exclusive access to the tree and no + /// concurrent accesses can happen. Effectively, this can only be guaranteed if the tree has just been created, + /// and it hasn't been returned to any function which might concurrently access it. + func setSyntaxTrackingOfTree(_ syntaxTracking: SyntaxTracking?) { + precondition(rootInfo.pointee.syntaxTracking == nil) + mutableRootInfo.pointee.syntaxTracking = syntaxTracking + } + /// The position of the start of this node's leading trivia public var position: AbsolutePosition { AbsolutePosition(utf8Offset: Int(absoluteInfo.offset)) @@ -135,7 +213,7 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { } init(_ raw: RawSyntax, parent: Syntax, absoluteInfo: AbsoluteSyntaxInfo) { - self.init(raw, info: Info(.nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo)))) + self.init(raw, info: Info(.nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo, rootInfo: parent.rootInfo)))) } /// Creates a `Syntax` with the provided raw syntax and parent. @@ -155,12 +233,22 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { /// has a chance to retain it. static func forRoot(_ raw: RawSyntax, rawNodeArena: RetainedSyntaxArena) -> Syntax { precondition(rawNodeArena == raw.arenaReference) - return Syntax(raw, info: Info(.root(.init(arena: rawNodeArena)))) + return Syntax( + raw, + info: Info(.root(Syntax.Info.RefCountedRoot(Syntax.Info.Root(arena: rawNodeArena, syntaxTracking: nil)))) + ) } static func forRoot(_ raw: RawSyntax, rawNodeArena: SyntaxArena) -> Syntax { precondition(rawNodeArena == raw.arenaReference) - return Syntax(raw, info: Info(.root(.init(arena: RetainedSyntaxArena(rawNodeArena))))) + return Syntax( + raw, + info: Info( + .root( + Syntax.Info.RefCountedRoot(Syntax.Info.Root(arena: RetainedSyntaxArena(rawNodeArena), syntaxTracking: nil)) + ) + ) + ) } /// Returns the child data at the provided index in this data's layout. @@ -256,12 +344,23 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable { /// `newChild` has been addded to the result. func replacingChild(at index: Int, with newChild: Syntax?, arena: SyntaxArena) -> Syntax { return withExtendedLifetime(newChild) { - return replacingChild( + let result = replacingChild( at: index, with: newChild?.raw, rawNodeArena: newChild?.raw.arenaReference.retained, allocationArena: arena ) + if trackedTree != nil { + var iter = RawSyntaxChildren(absoluteRaw).makeIterator() + for _ in 0.. SyntaxIndexInTree { let newIndexInTree = self.indexInTree + UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0) - return .init(indexInTree: newIndexInTree) + return .init(newIndexInTree) } /// Assuming that this index points to the next sibling of `raw`, reverse it so that it points to the start of /// `raw`. func reversedBy(_ raw: RawSyntax?) -> SyntaxIndexInTree { let newIndexInTree = self.indexInTree - UInt32(truncatingIfNeeded: raw?.totalNodes ?? 0) - return .init(indexInTree: newIndexInTree) + return .init(newIndexInTree) } func advancedToFirstChild() -> SyntaxIndexInTree { let newIndexInTree = self.indexInTree + 1 - return .init(indexInTree: newIndexInTree) + return .init(newIndexInTree) } - init(indexInTree: UInt32) { + init(_ indexInTree: UInt32) { self.indexInTree = indexInTree } @@ -66,6 +78,11 @@ public struct SyntaxIdentifier: Comparable, Hashable, Sendable { public init(fromOpaque opaque: UInt64) { self.indexInTree = UInt32(opaque) } + + /// Returns `true` if `lhs` occurs before `rhs` in the tree. + public static func < (lhs: SyntaxIndexInTree, rhs: SyntaxIndexInTree) -> Bool { + return lhs.indexInTree < rhs.indexInTree + } } /// Unique value for the root node. @@ -74,14 +91,14 @@ public struct SyntaxIdentifier: Comparable, Hashable, Sendable { /// same instance. This guarantees that the trees with the same 'rootId' have /// exact the same structure. But, two trees with exactly the same structure /// might still have different 'rootId's. - let rootId: UInt + let rootId: RootID /// Unique value for a node within its own tree. public let indexInTree: SyntaxIndexInTree /// Returns the `UInt` that is used as the root ID for the given raw syntax node. - private static func rootId(of raw: RawSyntax) -> UInt { - return UInt(bitPattern: raw.pointer.unsafeRawPointer) + private static func rootId(of raw: RawSyntax) -> RootID { + return RootID(raw.pointer.unsafeRawPointer) } func advancedBySibling(_ raw: RawSyntax?) -> SyntaxIdentifier { @@ -97,7 +114,7 @@ public struct SyntaxIdentifier: Comparable, Hashable, Sendable { static func forRoot(_ raw: RawSyntax) -> SyntaxIdentifier { return SyntaxIdentifier( rootId: Self.rootId(of: raw), - indexInTree: SyntaxIndexInTree(indexInTree: 0) + indexInTree: SyntaxIndexInTree(0) ) } @@ -121,7 +138,7 @@ public struct SyntaxIdentifier: Comparable, Hashable, Sendable { guard !root.hasParent else { return nil } - guard indexInTree.indexInTree < SyntaxIndexInTree(indexInTree: 0).advancedBy(root.raw).indexInTree else { + guard indexInTree.indexInTree < SyntaxIndexInTree(0).advancedBy(root.raw).indexInTree else { return nil } diff --git a/Sources/SwiftSyntax/SyntaxNodeFactory.swift b/Sources/SwiftSyntax/SyntaxNodeFactory.swift index 9246603e892..f51927e5f33 100644 --- a/Sources/SwiftSyntax/SyntaxNodeFactory.swift +++ b/Sources/SwiftSyntax/SyntaxNodeFactory.swift @@ -65,7 +65,7 @@ struct SyntaxNodeFactory { @inline(__always) func create(parent: Syntax, raw: RawSyntax, absoluteInfo: AbsoluteSyntaxInfo) -> Syntax { if let info = syntaxInfoRepo.pop() { - info.info = .nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo)) + info.info = .nonRoot(.init(parent: parent, absoluteInfo: absoluteInfo, rootInfo: parent.rootInfo)) return Syntax(raw, info: info) } else { return Syntax(raw, parent: parent, absoluteInfo: absoluteInfo) diff --git a/Sources/SwiftSyntax/SyntaxProtocol.swift b/Sources/SwiftSyntax/SyntaxProtocol.swift index 07c5f7b3077..c3960edc1a9 100644 --- a/Sources/SwiftSyntax/SyntaxProtocol.swift +++ b/Sources/SwiftSyntax/SyntaxProtocol.swift @@ -159,7 +159,9 @@ extension SyntaxProtocol { // Make sure `self` (and thus the arena of `self.raw`) can’t get deallocated // before the detached node can be created. return withExtendedLifetime(self) { - return Syntax(raw: self.raw, rawNodeArena: self.raw.arenaReference.retained).cast(Self.self) + let result = Syntax(raw: self.raw, rawNodeArena: self.raw.arenaReference.retained) + result.setSyntaxTrackingOfTree(SyntaxTracking(trackingRoot: Syntax(self))) + return result.cast(Self.self) } } } diff --git a/Sources/SwiftSyntax/SyntaxTracking.swift b/Sources/SwiftSyntax/SyntaxTracking.swift new file mode 100644 index 00000000000..153f2d75643 --- /dev/null +++ b/Sources/SwiftSyntax/SyntaxTracking.swift @@ -0,0 +1,393 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// MARK: Utilities + +fileprivate typealias SyntaxIndexInTree = SyntaxIdentifier.SyntaxIndexInTree + +fileprivate extension Comparable { + /// Adjusts this value so that it guaranteed to be in `range`. + func clamped(to range: Range) -> Self { + return min(max(self, range.lowerBound), range.upperBound) + } +} + +fileprivate extension Range { + func split(by split: Range) -> (before: Range, after: Range) { + let before = self.lowerBound.. { + func translated(by offset: Int) -> Range { + return SyntaxIndexInTree( + UInt32(Int(self.lowerBound.indexInTree) + offset) + ).. { + return id.indexInTree.. + + /// The number that needs to be added to `indexInTree` to get the node in + /// the tracked tree. + var offset: Int + + /// Shift the tracked range so that it tracks nodes that are now `shift` + /// nodes further in the tree. + /// + /// This shifts the tracked range upwards by `offset` and the offset down by + /// `shift` so that the tracked nodes still point to the original nodes. + func translated(by shift: Int) -> Self { + return TrackedRange( + range: self.range.translated(by: shift), + offset: self.offset - shift + ) + } + } + + /// The ID of the tree to which tracked ranges can translate the syntax nodes. + fileprivate var trackedTree: RootID + + /// Stores the actual tracked ranges + private var trackedRanges: [TrackedRange] = [] { + didSet { + assertNoOverlappingTrackedRanges() + } + } + + fileprivate init(trackedTree: RootID, trackedRanges: [TrackedRange]) { + self.trackedTree = trackedTree + self.trackedRanges = trackedRanges + } + + /// Update the `SyntaxTracking` to account for `oldNode` being replaced by `newNode`. + /// + /// It does the following + /// - Shift all tracked ranges after `oldNode` to account for the fact that + /// `newNode` might have more or fewer nodes than `oldNode` + /// - Incorporate the tracked ranges of `newNode` into this `SyntaxTracking`. + /// + /// - Complexity: O(trackedRanges.count + newNode.trackedRanges.count) + func replacing( + oldIndexInTree: SyntaxIdentifier.SyntaxIndexInTree, + oldTotalNodes: Int, + by newNode: Syntax? + ) -> SyntaxTracking { + let replacedRange = oldIndexInTree.. [TrackedRange] in + let (before, after) = tracked.range.split(by: replacedRange) + // - The ranges before the replaced nodes don't need to be adjusted + // - The ranges after the replaced range need to be adjusted: + // - The range needs to be shifted upwards if the new node has more + // total subtree nodes + // - Because we shift the range upwards we need to shift the offset down + // correspondingly. + let offset = (newNode?.raw.totalNodes ?? 0) - oldTotalNodes + return [ + TrackedRange(range: before, offset: tracked.offset), + TrackedRange(range: after, offset: tracked.offset).translated(by: offset), + ].filter { !$0.range.isEmpty } + } + + // If the new node has nodes that are being tracked in `trackedTree` + // transfer these translations to the new tracked ranges. + if let newNode, + let newNodeSyntaxTracking = newNode.syntaxTracking, newNodeSyntaxTracking.trackedTree == trackedTree + { + newTrackedRanges += newNodeSyntaxTracking.trackedRanges.map { tracked in + let offset = Int(oldIndexInTree.indexInTree) - Int(newNode.id.indexInTree.indexInTree) + return tracked.translated(by: offset) + } + } + return SyntaxTracking(trackedTree: self.trackedTree, trackedRanges: newTrackedRanges) + } + + /// If `originalNode` has an original node within this `SyntaxTracking`'s + /// `trackedTree` add an association of the node within a new tree to the + /// tracked tree. + /// + /// - Parameters: + /// - originalNode: The node in the original tree. Note that this doesn't + /// have to be a node within the tracked tree. It can be a node in a + /// derived tree that itself tracks `trackedTree`. + /// - nodeIndexInNewTree: The `SyntaxIndexInTree` of the node within the new + /// tree. + /// - Complexity: O(newNode.trackedRanges.count) + fileprivate mutating func track(originalNode: Syntax, nodeIndexInNewTree: SyntaxIndexInTree) { + guard originalNode.trackedTree == trackedTree else { + // The node doesn't track the same tracked tree (or doesn't track any tree). + // So there's nothing to do. + return + } + + // Find the tracked ranges in the original node that allow the translation + // of nodes within the subtree of `originalNode` to be translated to nodes + // in the tracked tree. + guard let originalNodeTranslationRanges = originalNode.syntaxTracking?.trackedRanges(of: originalNode) else { + return + } + + // Adjust the tracked ranges and their offsets to refer to nodes in the new tree. + let offset = Int(nodeIndexInNewTree.indexInTree) - Int(originalNode.id.indexInTree.indexInTree) + self.trackedRanges += originalNodeTranslationRanges.map { tracked in + return tracked.translated(by: offset) + } + } + + /// Return all tracked ranges of `node`. + /// + /// I.e. this returns all tracked ranges in this `SyntaxTracking` clamped to + /// the ranges that affect `node`. + /// + /// - Complexity: O(trackedRanges.count) + fileprivate func trackedRanges(of node: Syntax) -> [TrackedRange] { + let nodeIndexInTreeRange = node.indexInTreeRange + return trackedRanges.compactMap { tracked -> TrackedRange? in + let clamped = tracked.range.clamped(to: nodeIndexInTreeRange) + if clamped.isEmpty { + return nil + } + return TrackedRange(range: clamped, offset: tracked.offset) + } + } + + /// Translate the `SyntaxIndexInTree` of a syntax node to the `SyntaxIndexInTree` + /// in `trackedTree`. + /// + /// This is the main entry point to find the original node in a tracked tree. + /// + /// - Complexity: O(trackedRanges.count) + func originalIndexInTree( + of derivedIndexInTree: SyntaxIdentifier.SyntaxIndexInTree + ) -> SyntaxIdentifier.SyntaxIndexInTree? { + for tracked in trackedRanges { + if tracked.range.contains(derivedIndexInTree) { + return SyntaxIndexInTree(UInt32(Int(derivedIndexInTree.indexInTree) + tracked.offset)) + } + } + return nil + } + + /// Assert that the tracked ranges don't overlap. + /// + /// - Complexity: O(trackedRanges.count ^ 2) + private func assertNoOverlappingTrackedRanges() { + #if DEBUG || SWIFTSYNTAX_ENABLE_ASSERTIONS + for xIndex in trackedRanges.indices { + for yIndex in trackedRanges.index(after: xIndex).. SyntaxVisitorContinueKind { + if node.id.indexInTree == indexInTree { + assert(found == nil) + found = node + } + if node.indexInTreeRange.contains(indexInTree) { + return .visitChildren + } else { + return .skipChildren + } + } +} + +extension SyntaxProtocol { + /// Start tracking this syntax tree as the original tree for all trees derived + /// from it. + /// + /// All syntax nodes derived from the returned, tracked, tree will be able to + /// find the corresponding node in the original tree by calling + /// ``SyntaxProtocol/originalNode(in:)``. + /// + /// Derived nodes are + /// - Nodes that contain a node from this tree as a subtree. + /// - Nodes that resulted from modification of a node in this tree (e.g. + /// modification of a child node or insertion of an element into a + /// collection). + /// - Detached subtrees of this tree (see ``SyntaxProtocol/detached``). + /// + /// Node tracking is not enabled by default because maintaining the mapping + /// back to the tracked tree has a performance cost that. + /// + /// A tree can only track a single original tree. I.e. it is not possible to + /// create a node that has one child in tracked tree A and another child in + /// tracked tree B. In practice, this should seldom pose an issue because the + /// most common use case is to mark the tree obtained from a file on disk as + /// the tracked tree and trees from separate source files will rarely be + /// merged. + /// + /// - SeeAlso: ``SyntaxProtocol/originalNode(in:)`` + /// - Complexity: O(number of ancestors) + public var tracked: Self { + return Syntax(self).tracked.cast(Self.self) + } + + /// If this syntax node is tracking `originalTree` and this node originated + /// from that tree, return the corresponding corresponding node in + /// `originalTree`. + /// + /// The original node will have the same structure as this node but the parent + /// might be different since it's anchored in `originalTree`. + /// + /// The original node's source location will be the location that the node had + /// in `originalTree`. + /// + /// - SeeAlso: ``SyntaxProtocol/tracked`` + /// - Complexity: O(tracked ranges in this tree) + O(width * depth of original tree) + public func originalNode(in originalTree: some SyntaxProtocol) -> Self? { + guard Syntax(self).syntaxTracking?.trackedTree == originalTree.id.rootId else { + return nil + } + guard let originalIndexInTree = Syntax(self).syntaxTracking?.originalIndexInTree(of: self.id.indexInTree) else { + return nil + } + + let finder = IndexInTreeFinder(indexInTree: originalIndexInTree) + finder.walk(originalTree.root) + return finder.found?.cast(Self.self) + } +} + +// MARK: To be generated + +extension SyntaxTracking { + /// Find the tree that should be tracked by a node that has the given nodes as + /// children. + /// + /// If all syntax nodes that have tracking enabled track the same tree, return + /// that tree's root ID. + /// + /// If no nodes track any tree or there are two nodes that track conflicting + /// trees, return `nil`. + /// + /// - Complexity: O(nodes.count) + @inline(__always) + private static func treeToTrack(_ nodes: [Syntax?]) -> RootID? { + var treeToTrack: RootID? = nil + for case .some(let node) in nodes { + if treeToTrack == nil { + treeToTrack = node.trackedTree + } else if node.trackedTree != nil && treeToTrack != node.trackedTree { + return nil + } + } + return treeToTrack + } + + /// Construct a new `SyntaxTracking` that tracks all `nodes` in a new node. + /// that has `nodes` as children. + /// + /// - Complexity: O(Σ_(n in nodes) 1 + n.trackedRanges.count) i.e. O(nodes.count) if no node tracks a tree. + @inline(__always) + // FIXME: Rename to trackingChildren + init?(tracking nodes: [Syntax?]) { + guard let treeToTrack = SyntaxTracking.treeToTrack(nodes) else { + return nil + } + self.init(trackedTree: treeToTrack, trackedRanges: []) + var indexInTree = SyntaxIndexInTree(0).advancedToFirstChild() + for case .some(let node) in nodes { + self.track(originalNode: node, nodeIndexInNewTree: indexInTree) + indexInTree = indexInTree.advancedBy(node.raw) + } + } + + /// Construct a new `SyntaxTracking` that tracks all `nodes` in a new node. + /// that has `nodes` as children. + /// + /// - Complexity: O(Σ_(n in nodes) 1 + n.trackedRanges.count) i.e. O(nodes.count) if no node tracks a tree. + @inline(__always) + init?(trackingRoot node: Syntax) { + guard let treeToTrack = node.trackedTree else { + return nil + } + self.init(trackedTree: treeToTrack, trackedRanges: []) + self.track(originalNode: node, nodeIndexInNewTree: SyntaxIndexInTree(0)) + } +} diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift index 136a9cf9237..5c72cddb108 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift @@ -133,29 +133,21 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftBrace), + Syntax(leftBrace), + Syntax(unexpectedBetweenLeftBraceAndAccessors), + Syntax(accessors), + Syntax(unexpectedBetweenAccessorsAndRightBrace), + Syntax(rightBrace), + Syntax(unexpectedAfterRightBrace) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndAccessors, - accessors, - unexpectedBetweenAccessorsAndRightBrace, - rightBrace, - unexpectedAfterRightBrace - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndAccessors?.raw, - accessors.raw, - unexpectedBetweenAccessorsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorBlock, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -163,6 +155,7 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { @@ -294,41 +287,27 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifier), + Syntax(modifier), + Syntax(unexpectedBetweenModifierAndAccessorSpecifier), + Syntax(accessorSpecifier), + Syntax(unexpectedBetweenAccessorSpecifierAndParameters), + Syntax(parameters), + Syntax(unexpectedBetweenParametersAndEffectSpecifiers), + Syntax(effectSpecifiers), + Syntax(unexpectedBetweenEffectSpecifiersAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifier, - modifier, - unexpectedBetweenModifierAndAccessorSpecifier, - accessorSpecifier, - unexpectedBetweenAccessorSpecifierAndParameters, - parameters, - unexpectedBetweenParametersAndEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifier?.raw, - modifier?.raw, - unexpectedBetweenModifierAndAccessorSpecifier?.raw, - accessorSpecifier.raw, - unexpectedBetweenAccessorSpecifierAndParameters?.raw, - parameters?.raw, - unexpectedBetweenParametersAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndBody?.raw, - body?.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -336,6 +315,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -371,7 +351,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -550,25 +530,19 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAsyncSpecifier), + Syntax(asyncSpecifier), + Syntax(unexpectedBetweenAsyncSpecifierAndThrowsClause), + Syntax(throwsClause), + Syntax(unexpectedAfterThrowsClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAsyncSpecifier, - asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsClause, - throwsClause, - unexpectedAfterThrowsClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAsyncSpecifier?.raw, - asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw, - throwsClause?.raw, - unexpectedAfterThrowsClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorEffectSpecifiers, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -576,6 +550,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { @@ -674,29 +649,21 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndName, - name, - unexpectedBetweenNameAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndName?.raw, - name.raw, - unexpectedBetweenNameAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.accessorParameters, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -704,6 +671,7 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -841,49 +809,31 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndActorKeyword), + Syntax(actorKeyword), + Syntax(unexpectedBetweenActorKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndMemberBlock), + Syntax(memberBlock), + Syntax(unexpectedAfterMemberBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndActorKeyword, - actorKeyword, - unexpectedBetweenActorKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndActorKeyword?.raw, - actorKeyword.raw, - unexpectedBetweenActorKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.actorDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -891,6 +841,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -926,7 +877,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -972,7 +923,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1169,25 +1120,19 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.arrayElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1195,6 +1140,7 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -1288,29 +1234,21 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndElements), + Syntax(elements), + Syntax(unexpectedBetweenElementsAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedAfterRightSquare) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndElements, - elements, - unexpectedBetweenElementsAndRightSquare, - rightSquare, - unexpectedAfterRightSquare - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndElements?.raw, - elements.raw, - unexpectedBetweenElementsAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.arrayExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1318,6 +1256,7 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { @@ -1374,7 +1313,7 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.arrayElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1459,29 +1398,21 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndElement), + Syntax(element), + Syntax(unexpectedBetweenElementAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedAfterRightSquare) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndElement, - element, - unexpectedBetweenElementAndRightSquare, - rightSquare, - unexpectedAfterRightSquare - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndElement?.raw, - element.raw, - unexpectedBetweenElementAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.arrayType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1489,6 +1420,7 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { @@ -1610,25 +1542,19 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeEffectSpecifiers), + Syntax(effectSpecifiers), + Syntax(unexpectedBetweenEffectSpecifiersAndArrow), + Syntax(arrow), + Syntax(unexpectedAfterArrow) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndArrow, - arrow, - unexpectedAfterArrow - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndArrow?.raw, - arrow.raw, - unexpectedAfterArrow?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.arrowExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1636,6 +1562,7 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeEffectSpecifiers: UnexpectedNodesSyntax? { @@ -1745,33 +1672,23 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndAsKeyword), + Syntax(asKeyword), + Syntax(unexpectedBetweenAsKeywordAndQuestionOrExclamationMark), + Syntax(questionOrExclamationMark), + Syntax(unexpectedBetweenQuestionOrExclamationMarkAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndAsKeyword, - asKeyword, - unexpectedBetweenAsKeywordAndQuestionOrExclamationMark, - questionOrExclamationMark, - unexpectedBetweenQuestionOrExclamationMarkAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndAsKeyword?.raw, - asKeyword.raw, - unexpectedBetweenAsKeywordAndQuestionOrExclamationMark?.raw, - questionOrExclamationMark?.raw, - unexpectedBetweenQuestionOrExclamationMarkAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.asExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1779,6 +1696,7 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -1909,13 +1827,13 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeEqual), Syntax(equal), Syntax(unexpectedAfterEqual)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeEqual, equal, unexpectedAfterEqual))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeEqual?.raw, equal.raw, unexpectedAfterEqual?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.assignmentExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1923,6 +1841,7 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { @@ -2035,45 +1954,29 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndAssociatedtypeKeyword), + Syntax(associatedtypeKeyword), + Syntax(unexpectedBetweenAssociatedtypeKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndInitializer), + Syntax(initializer), + Syntax(unexpectedBetweenInitializerAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedAfterGenericWhereClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndAssociatedtypeKeyword, - associatedtypeKeyword, - unexpectedBetweenAssociatedtypeKeywordAndName, - name, - unexpectedBetweenNameAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndInitializer, - initializer, - unexpectedBetweenInitializerAndGenericWhereClause, - genericWhereClause, - unexpectedAfterGenericWhereClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndAssociatedtypeKeyword?.raw, - associatedtypeKeyword.raw, - unexpectedBetweenAssociatedtypeKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndInitializer?.raw, - initializer?.raw, - unexpectedBetweenInitializerAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedAfterGenericWhereClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.associatedTypeDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2081,6 +1984,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2117,7 +2021,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2163,7 +2067,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3053,37 +2957,25 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAtSign), + Syntax(atSign), + Syntax(unexpectedBetweenAtSignAndAttributeName), + Syntax(attributeName), + Syntax(unexpectedBetweenAttributeNameAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAtSign, - atSign, - unexpectedBetweenAtSignAndAttributeName, - attributeName, - unexpectedBetweenAttributeNameAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAtSign?.raw, - atSign.raw, - unexpectedBetweenAtSignAndAttributeName?.raw, - attributeName.raw, - unexpectedBetweenAttributeNameAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments?.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.attribute, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3091,6 +2983,7 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAtSign: UnexpectedNodesSyntax? { @@ -3262,29 +3155,21 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeSpecifiers), + Syntax(specifiers), + Syntax(unexpectedBetweenSpecifiersAndAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndBaseType), + Syntax(baseType), + Syntax(unexpectedAfterBaseType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSpecifiers, - specifiers, - unexpectedBetweenSpecifiersAndAttributes, - attributes, - unexpectedBetweenAttributesAndBaseType, - baseType, - unexpectedAfterBaseType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifiers?.raw, - specifiers.raw, - unexpectedBetweenSpecifiersAndAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndBaseType?.raw, - baseType.raw, - unexpectedAfterBaseType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.attributedType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3292,6 +3177,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSpecifiers: UnexpectedNodesSyntax? { @@ -3328,7 +3214,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.typeSpecifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3374,7 +3260,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3577,25 +3463,19 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeArgument), + Syntax(argument), + Syntax(unexpectedBetweenArgumentAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeArgument, - argument, - unexpectedBetweenArgumentAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeArgument?.raw, - argument.raw, - unexpectedBetweenArgumentAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.availabilityArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3603,6 +3483,7 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeArgument: UnexpectedNodesSyntax? { @@ -3704,33 +3585,23 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAvailabilityKeyword), + Syntax(availabilityKeyword), + Syntax(unexpectedBetweenAvailabilityKeywordAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndAvailabilityArguments), + Syntax(availabilityArguments), + Syntax(unexpectedBetweenAvailabilityArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAvailabilityKeyword, - availabilityKeyword, - unexpectedBetweenAvailabilityKeywordAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndAvailabilityArguments, - availabilityArguments, - unexpectedBetweenAvailabilityArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAvailabilityKeyword?.raw, - availabilityKeyword.raw, - unexpectedBetweenAvailabilityKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndAvailabilityArguments?.raw, - availabilityArguments.raw, - unexpectedBetweenAvailabilityArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.availabilityCondition, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3738,6 +3609,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? { @@ -3817,7 +3689,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityArgumentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3995,29 +3867,21 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable, trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedAfterValue) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedAfterValue - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.availabilityLabeledArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4025,6 +3889,7 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable, ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -4146,25 +4011,19 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAwaitKeyword), + Syntax(awaitKeyword), + Syntax(unexpectedBetweenAwaitKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAwaitKeyword, - awaitKeyword, - unexpectedBetweenAwaitKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAwaitKeyword?.raw, - awaitKeyword.raw, - unexpectedBetweenAwaitKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.awaitExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4172,6 +4031,7 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAwaitKeyword: UnexpectedNodesSyntax? { @@ -4272,29 +4132,21 @@ public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashab trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBeforeLabel), + Syntax(beforeLabel), + Syntax(unexpectedBetweenBeforeLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndPlatforms), + Syntax(platforms), + Syntax(unexpectedAfterPlatforms) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBeforeLabel, - beforeLabel, - unexpectedBetweenBeforeLabelAndColon, - colon, - unexpectedBetweenColonAndPlatforms, - platforms, - unexpectedAfterPlatforms - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBeforeLabel?.raw, - beforeLabel.raw, - unexpectedBetweenBeforeLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndPlatforms?.raw, - platforms.raw, - unexpectedAfterPlatforms?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.backDeployedAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4302,6 +4154,7 @@ public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashab ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? { @@ -4384,7 +4237,7 @@ public struct BackDeployedAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashab collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.platformVersionItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4448,13 +4301,13 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeOperator), Syntax(`operator`), Syntax(unexpectedAfterOperator)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeOperator, `operator`, unexpectedAfterOperator))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeOperator?.raw, `operator`.raw, unexpectedAfterOperator?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.binaryOperatorExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4462,6 +4315,7 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeOperator: UnexpectedNodesSyntax? { @@ -4523,13 +4377,13 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeLiteral), Syntax(literal), Syntax(unexpectedAfterLiteral)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLiteral, literal, unexpectedAfterLiteral))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeLiteral?.raw, literal.raw, unexpectedAfterLiteral?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.booleanLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4537,6 +4391,7 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLiteral: UnexpectedNodesSyntax? { @@ -4603,25 +4458,19 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBorrowKeyword), + Syntax(borrowKeyword), + Syntax(unexpectedBetweenBorrowKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBorrowKeyword, - borrowKeyword, - unexpectedBetweenBorrowKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBorrowKeyword?.raw, - borrowKeyword.raw, - unexpectedBetweenBorrowKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.borrowExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4629,6 +4478,7 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBorrowKeyword: UnexpectedNodesSyntax? { @@ -4717,25 +4567,19 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBreakKeyword), + Syntax(breakKeyword), + Syntax(unexpectedBetweenBreakKeywordAndLabel), + Syntax(label), + Syntax(unexpectedAfterLabel) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBreakKeyword, - breakKeyword, - unexpectedBetweenBreakKeywordAndLabel, - label, - unexpectedAfterLabel - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBreakKeyword?.raw, - breakKeyword.raw, - unexpectedBetweenBreakKeywordAndLabel?.raw, - label?.raw, - unexpectedAfterLabel?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.breakStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4743,6 +4587,7 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift index bfdce0dd3ce..5cc11527e69 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift @@ -50,37 +50,25 @@ public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCanImportKeyword), + Syntax(canImportKeyword), + Syntax(unexpectedBetweenCanImportKeywordAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndImportPath), + Syntax(importPath), + Syntax(unexpectedBetweenImportPathAndVersionInfo), + Syntax(versionInfo), + Syntax(unexpectedBetweenVersionInfoAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCanImportKeyword, - canImportKeyword, - unexpectedBetweenCanImportKeywordAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndImportPath, - importPath, - unexpectedBetweenImportPathAndVersionInfo, - versionInfo, - unexpectedBetweenVersionInfoAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCanImportKeyword?.raw, - canImportKeyword.raw, - unexpectedBetweenCanImportKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndImportPath?.raw, - importPath.raw, - unexpectedBetweenImportPathAndVersionInfo?.raw, - versionInfo?.raw, - unexpectedBetweenVersionInfoAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind._canImportExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -88,6 +76,7 @@ public struct _CanImportExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCanImportKeyword: UnexpectedNodesSyntax? { @@ -255,33 +244,23 @@ public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndVersion), + Syntax(version), + Syntax(unexpectedAfterVersion) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeComma, - comma, - unexpectedBetweenCommaAndLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndVersion, - version, - unexpectedAfterVersion - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeComma?.raw, - comma.raw, - unexpectedBetweenCommaAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndVersion?.raw, - version.raw, - unexpectedAfterVersion?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind._canImportVersionInfo, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -289,6 +268,7 @@ public struct _CanImportVersionInfoSyntax: ExprSyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeComma: UnexpectedNodesSyntax? { @@ -432,29 +412,21 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCatchKeyword), + Syntax(catchKeyword), + Syntax(unexpectedBetweenCatchKeywordAndCatchItems), + Syntax(catchItems), + Syntax(unexpectedBetweenCatchItemsAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCatchKeyword, - catchKeyword, - unexpectedBetweenCatchKeywordAndCatchItems, - catchItems, - unexpectedBetweenCatchItemsAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCatchKeyword?.raw, - catchKeyword.raw, - unexpectedBetweenCatchKeywordAndCatchItems?.raw, - catchItems.raw, - unexpectedBetweenCatchItemsAndBody?.raw, - body.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.catchClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -462,6 +434,7 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCatchKeyword: UnexpectedNodesSyntax? { @@ -518,7 +491,7 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.catchItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -604,29 +577,21 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndWhereClause), + Syntax(whereClause), + Syntax(unexpectedBetweenWhereClauseAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePattern, - pattern, - unexpectedBetweenPatternAndWhereClause, - whereClause, - unexpectedBetweenWhereClauseAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern?.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.catchItem, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -634,6 +599,7 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePattern: UnexpectedNodesSyntax? { @@ -792,49 +758,31 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndClassKeyword), + Syntax(classKeyword), + Syntax(unexpectedBetweenClassKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndMemberBlock), + Syntax(memberBlock), + Syntax(unexpectedAfterMemberBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndClassKeyword, - classKeyword, - unexpectedBetweenClassKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndClassKeyword?.raw, - classKeyword.raw, - unexpectedBetweenClassKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.classDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -842,6 +790,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -878,7 +827,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -924,7 +873,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1114,13 +1063,13 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeClassKeyword), Syntax(classKeyword), Syntax(unexpectedAfterClassKeyword)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeClassKeyword, classKeyword, unexpectedAfterClassKeyword))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeClassKeyword?.raw, classKeyword.raw, unexpectedAfterClassKeyword?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.classRestrictionType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1128,6 +1077,7 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeClassKeyword: UnexpectedNodesSyntax? { @@ -1199,29 +1149,21 @@ public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndItems), + Syntax(items), + Syntax(unexpectedBetweenItemsAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedAfterRightSquare) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndItems, - items, - unexpectedBetweenItemsAndRightSquare, - rightSquare, - unexpectedAfterRightSquare - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndItems?.raw, - items.raw, - unexpectedBetweenItemsAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureCaptureClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1229,6 +1171,7 @@ public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { @@ -1285,7 +1228,7 @@ public struct ClosureCaptureClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.closureCaptureList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1377,33 +1320,23 @@ public struct ClosureCaptureSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeSpecifier), + Syntax(specifier), + Syntax(unexpectedBetweenSpecifierAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndDetail), + Syntax(detail), + Syntax(unexpectedBetweenDetailAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSpecifier, - specifier, - unexpectedBetweenSpecifierAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndDetail, - detail, - unexpectedBetweenDetailAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier.raw, - unexpectedBetweenSpecifierAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndDetail?.raw, - detail?.raw, - unexpectedBetweenDetailAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureCaptureSpecifier, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1411,6 +1344,7 @@ public struct ClosureCaptureSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { @@ -1565,37 +1499,25 @@ public struct ClosureCaptureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeSpecifier), + Syntax(specifier), + Syntax(unexpectedBetweenSpecifierAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndEqual), + Syntax(equal), + Syntax(unexpectedBetweenEqualAndExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSpecifier, - specifier, - unexpectedBetweenSpecifierAndName, - name, - unexpectedBetweenNameAndEqual, - equal, - unexpectedBetweenEqualAndExpression, - expression, - unexpectedBetweenExpressionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSpecifier?.raw, - specifier?.raw, - unexpectedBetweenSpecifierAndName?.raw, - name?.raw, - unexpectedBetweenNameAndEqual?.raw, - equal?.raw, - unexpectedBetweenEqualAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureCapture, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1603,6 +1525,7 @@ public struct ClosureCaptureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { @@ -1771,33 +1694,23 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftBrace), + Syntax(leftBrace), + Syntax(unexpectedBetweenLeftBraceAndSignature), + Syntax(signature), + Syntax(unexpectedBetweenSignatureAndStatements), + Syntax(statements), + Syntax(unexpectedBetweenStatementsAndRightBrace), + Syntax(rightBrace), + Syntax(unexpectedAfterRightBrace) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndSignature, - signature, - unexpectedBetweenSignatureAndStatements, - statements, - unexpectedBetweenStatementsAndRightBrace, - rightBrace, - unexpectedAfterRightBrace - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndSignature?.raw, - signature?.raw, - unexpectedBetweenSignatureAndStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1805,6 +1718,7 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { @@ -1879,7 +1793,7 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1973,29 +1887,21 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndParameters), + Syntax(parameters), + Syntax(unexpectedBetweenParametersAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndParameters, - parameters, - unexpectedBetweenParametersAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndParameters?.raw, - parameters.raw, - unexpectedBetweenParametersAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureParameterClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2003,6 +1909,7 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -2062,7 +1969,7 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2174,49 +2081,31 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndFirstName), + Syntax(firstName), + Syntax(unexpectedBetweenFirstNameAndSecondName), + Syntax(secondName), + Syntax(unexpectedBetweenSecondNameAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndEllipsis), + Syntax(ellipsis), + Syntax(unexpectedBetweenEllipsisAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndFirstName, - firstName, - unexpectedBetweenFirstNameAndSecondName, - secondName, - unexpectedBetweenSecondNameAndColon, - colon, - unexpectedBetweenColonAndType, - type, - unexpectedBetweenTypeAndEllipsis, - ellipsis, - unexpectedBetweenEllipsisAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndFirstName?.raw, - firstName.raw, - unexpectedBetweenFirstNameAndSecondName?.raw, - secondName?.raw, - unexpectedBetweenSecondNameAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndType?.raw, - type?.raw, - unexpectedBetweenTypeAndEllipsis?.raw, - ellipsis?.raw, - unexpectedBetweenEllipsisAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureParameter, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2224,6 +2113,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2259,7 +2149,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2304,7 +2194,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2517,25 +2407,19 @@ public struct ClosureShorthandParameterSyntax: SyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureShorthandParameter, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2543,6 +2427,7 @@ public struct ClosureShorthandParameterSyntax: SyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -2734,41 +2619,27 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndCapture), + Syntax(capture), + Syntax(unexpectedBetweenCaptureAndParameterClause), + Syntax(parameterClause), + Syntax(unexpectedBetweenParameterClauseAndEffectSpecifiers), + Syntax(effectSpecifiers), + Syntax(unexpectedBetweenEffectSpecifiersAndReturnClause), + Syntax(returnClause), + Syntax(unexpectedBetweenReturnClauseAndInKeyword), + Syntax(inKeyword), + Syntax(unexpectedAfterInKeyword) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndCapture, - capture, - unexpectedBetweenCaptureAndParameterClause, - parameterClause, - unexpectedBetweenParameterClauseAndEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndReturnClause, - returnClause, - unexpectedBetweenReturnClauseAndInKeyword, - inKeyword, - unexpectedAfterInKeyword - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndCapture?.raw, - capture?.raw, - unexpectedBetweenCaptureAndParameterClause?.raw, - parameterClause?.raw, - unexpectedBetweenParameterClauseAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndReturnClause?.raw, - returnClause?.raw, - unexpectedBetweenReturnClauseAndInKeyword?.raw, - inKeyword.raw, - unexpectedAfterInKeyword?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.closureSignature, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2776,6 +2647,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2811,7 +2683,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3094,25 +2966,19 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeItem), + Syntax(item), + Syntax(unexpectedBetweenItemAndSemicolon), + Syntax(semicolon), + Syntax(unexpectedAfterSemicolon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeItem, - item, - unexpectedBetweenItemAndSemicolon, - semicolon, - unexpectedAfterSemicolon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeItem?.raw, - item.raw, - unexpectedBetweenItemAndSemicolon?.raw, - semicolon?.raw, - unexpectedAfterSemicolon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.codeBlockItem, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3120,6 +2986,7 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeItem: UnexpectedNodesSyntax? { @@ -3232,29 +3099,21 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftBrace), + Syntax(leftBrace), + Syntax(unexpectedBetweenLeftBraceAndStatements), + Syntax(statements), + Syntax(unexpectedBetweenStatementsAndRightBrace), + Syntax(rightBrace), + Syntax(unexpectedAfterRightBrace) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndStatements, - statements, - unexpectedBetweenStatementsAndRightBrace, - rightBrace, - unexpectedAfterRightBrace - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.codeBlock, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3262,6 +3121,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { @@ -3320,7 +3180,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3408,25 +3268,19 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndAmpersand), + Syntax(ampersand), + Syntax(unexpectedAfterAmpersand) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeType, - type, - unexpectedBetweenTypeAndAmpersand, - ampersand, - unexpectedAfterAmpersand - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndAmpersand?.raw, - ampersand?.raw, - unexpectedAfterAmpersand?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.compositionTypeElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3434,6 +3288,7 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeType: UnexpectedNodesSyntax? { @@ -3516,13 +3371,13 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeElements), Syntax(elements), Syntax(unexpectedAfterElements)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeElements, elements, unexpectedAfterElements))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeElements?.raw, elements.raw, unexpectedAfterElements?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.compositionType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3530,6 +3385,7 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeElements: UnexpectedNodesSyntax? { @@ -3565,7 +3421,7 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.compositionTypeElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3775,25 +3631,19 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCondition), + Syntax(condition), + Syntax(unexpectedBetweenConditionAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCondition, - condition, - unexpectedBetweenConditionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCondition?.raw, - condition.raw, - unexpectedBetweenConditionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.conditionElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3801,6 +3651,7 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { @@ -3896,29 +3747,21 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftType), + Syntax(leftType), + Syntax(unexpectedBetweenLeftTypeAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndRightType), + Syntax(rightType), + Syntax(unexpectedAfterRightType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftType, - leftType, - unexpectedBetweenLeftTypeAndColon, - colon, - unexpectedBetweenColonAndRightType, - rightType, - unexpectedAfterRightType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftType?.raw, - leftType.raw, - unexpectedBetweenLeftTypeAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndRightType?.raw, - rightType.raw, - unexpectedAfterRightType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.conformanceRequirement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3926,6 +3769,7 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftType: UnexpectedNodesSyntax? { @@ -4034,25 +3878,19 @@ public struct ConsumeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeConsumeKeyword), + Syntax(consumeKeyword), + Syntax(unexpectedBetweenConsumeKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeConsumeKeyword, - consumeKeyword, - unexpectedBetweenConsumeKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeConsumeKeyword?.raw, - consumeKeyword.raw, - unexpectedBetweenConsumeKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.consumeExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4060,6 +3898,7 @@ public struct ConsumeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeConsumeKeyword: UnexpectedNodesSyntax? { @@ -4150,25 +3989,19 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeContinueKeyword), + Syntax(continueKeyword), + Syntax(unexpectedBetweenContinueKeywordAndLabel), + Syntax(label), + Syntax(unexpectedAfterLabel) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeContinueKeyword, - continueKeyword, - unexpectedBetweenContinueKeywordAndLabel, - label, - unexpectedAfterLabel - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeContinueKeyword?.raw, - continueKeyword.raw, - unexpectedBetweenContinueKeywordAndLabel?.raw, - label?.raw, - unexpectedAfterLabel?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.continueStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4176,6 +4009,7 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeContinueKeyword: UnexpectedNodesSyntax? { @@ -4283,37 +4117,25 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeConventionLabel), + Syntax(conventionLabel), + Syntax(unexpectedBetweenConventionLabelAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndCTypeLabel), + Syntax(cTypeLabel), + Syntax(unexpectedBetweenCTypeLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndCTypeString), + Syntax(cTypeString), + Syntax(unexpectedAfterCTypeString) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeConventionLabel, - conventionLabel, - unexpectedBetweenConventionLabelAndComma, - comma, - unexpectedBetweenCommaAndCTypeLabel, - cTypeLabel, - unexpectedBetweenCTypeLabelAndColon, - colon, - unexpectedBetweenColonAndCTypeString, - cTypeString, - unexpectedAfterCTypeString - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeConventionLabel?.raw, - conventionLabel.raw, - unexpectedBetweenConventionLabelAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndCTypeLabel?.raw, - cTypeLabel?.raw, - unexpectedBetweenCTypeLabelAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndCTypeString?.raw, - cTypeString?.raw, - unexpectedAfterCTypeString?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.conventionAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4321,6 +4143,7 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? { @@ -4492,29 +4315,21 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWitnessMethodLabel), + Syntax(witnessMethodLabel), + Syntax(unexpectedBetweenWitnessMethodLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndProtocolName), + Syntax(protocolName), + Syntax(unexpectedAfterProtocolName) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWitnessMethodLabel, - witnessMethodLabel, - unexpectedBetweenWitnessMethodLabelAndColon, - colon, - unexpectedBetweenColonAndProtocolName, - protocolName, - unexpectedAfterProtocolName - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWitnessMethodLabel?.raw, - witnessMethodLabel.raw, - unexpectedBetweenWitnessMethodLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndProtocolName?.raw, - protocolName.raw, - unexpectedAfterProtocolName?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.conventionWitnessMethodAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4522,6 +4337,7 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? { @@ -4642,25 +4458,19 @@ public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCopyKeyword), + Syntax(copyKeyword), + Syntax(unexpectedBetweenCopyKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCopyKeyword, - copyKeyword, - unexpectedBetweenCopyKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCopyKeyword?.raw, - copyKeyword.raw, - unexpectedBetweenCopyKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.copyExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4668,6 +4478,7 @@ public struct CopyExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCopyKeyword: UnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift index f2b33bb792d..9db82adfc02 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesD.swift @@ -48,29 +48,21 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndDetail), + Syntax(detail), + Syntax(unexpectedBetweenDetailAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndDetail, - detail, - unexpectedBetweenDetailAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndDetail?.raw, - detail.raw, - unexpectedBetweenDetailAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.declModifierDetail, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -78,6 +70,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -197,25 +190,19 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndDetail), + Syntax(detail), + Syntax(unexpectedAfterDetail) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndDetail, - detail, - unexpectedAfterDetail - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndDetail?.raw, - detail?.raw, - unexpectedAfterDetail?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.declModifier, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -223,6 +210,7 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -351,25 +339,19 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndColon), + Syntax(colon), + Syntax(unexpectedAfterColon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndColon, - colon, - unexpectedAfterColon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.declNameArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -377,6 +359,7 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -472,29 +455,21 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.declNameArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -502,6 +477,7 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -558,7 +534,7 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -648,25 +624,19 @@ public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBaseName), + Syntax(baseName), + Syntax(unexpectedBetweenBaseNameAndArgumentNames), + Syntax(argumentNames), + Syntax(unexpectedAfterArgumentNames) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBaseName, - baseName, - unexpectedBetweenBaseNameAndArgumentNames, - argumentNames, - unexpectedAfterArgumentNames - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBaseName?.raw, - baseName.raw, - unexpectedBetweenBaseNameAndArgumentNames?.raw, - argumentNames?.raw, - unexpectedAfterArgumentNames?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.declReferenceExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -674,6 +644,7 @@ public struct DeclReferenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBaseName: UnexpectedNodesSyntax? { @@ -771,25 +742,19 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDeferKeyword), + Syntax(deferKeyword), + Syntax(unexpectedBetweenDeferKeywordAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDeferKeyword, - deferKeyword, - unexpectedBetweenDeferKeywordAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDeferKeyword?.raw, - deferKeyword.raw, - unexpectedBetweenDeferKeywordAndBody?.raw, - body.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.deferStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -797,6 +762,7 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDeferKeyword: UnexpectedNodesSyntax? { @@ -907,37 +873,25 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndDeinitKeyword), + Syntax(deinitKeyword), + Syntax(unexpectedBetweenDeinitKeywordAndEffectSpecifiers), + Syntax(effectSpecifiers), + Syntax(unexpectedBetweenEffectSpecifiersAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndDeinitKeyword, - deinitKeyword, - unexpectedBetweenDeinitKeywordAndEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndDeinitKeyword?.raw, - deinitKeyword.raw, - unexpectedBetweenDeinitKeywordAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndBody?.raw, - body?.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.deinitializerDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -945,6 +899,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -981,7 +936,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1027,7 +982,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1154,13 +1109,13 @@ public struct DeinitializerEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashabl trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeAsyncSpecifier), Syntax(asyncSpecifier), Syntax(unexpectedAfterAsyncSpecifier)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAsyncSpecifier, asyncSpecifier, unexpectedAfterAsyncSpecifier))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, unexpectedAfterAsyncSpecifier?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.deinitializerEffectSpecifiers, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1168,6 +1123,7 @@ public struct DeinitializerEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashabl ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { @@ -1260,45 +1216,29 @@ public struct DerivativeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeOfLabel), + Syntax(ofLabel), + Syntax(unexpectedBetweenOfLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndOriginalDeclName), + Syntax(originalDeclName), + Syntax(unexpectedBetweenOriginalDeclNameAndPeriod), + Syntax(period), + Syntax(unexpectedBetweenPeriodAndAccessorSpecifier), + Syntax(accessorSpecifier), + Syntax(unexpectedBetweenAccessorSpecifierAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndArguments), + Syntax(arguments), + Syntax(unexpectedAfterArguments) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeOfLabel, - ofLabel, - unexpectedBetweenOfLabelAndColon, - colon, - unexpectedBetweenColonAndOriginalDeclName, - originalDeclName, - unexpectedBetweenOriginalDeclNameAndPeriod, - period, - unexpectedBetweenPeriodAndAccessorSpecifier, - accessorSpecifier, - unexpectedBetweenAccessorSpecifierAndComma, - comma, - unexpectedBetweenCommaAndArguments, - arguments, - unexpectedAfterArguments - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeOfLabel?.raw, - ofLabel.raw, - unexpectedBetweenOfLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndOriginalDeclName?.raw, - originalDeclName.raw, - unexpectedBetweenOriginalDeclNameAndPeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndAccessorSpecifier?.raw, - accessorSpecifier?.raw, - unexpectedBetweenAccessorSpecifierAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndArguments?.raw, - arguments?.raw, - unexpectedAfterArguments?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.derivativeAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1306,6 +1246,7 @@ public struct DerivativeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeOfLabel: UnexpectedNodesSyntax? { @@ -1521,25 +1462,19 @@ public struct DesignatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeadingComma), + Syntax(leadingComma), + Syntax(unexpectedBetweenLeadingCommaAndName), + Syntax(name), + Syntax(unexpectedAfterName) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeadingComma, - leadingComma, - unexpectedBetweenLeadingCommaAndName, - name, - unexpectedAfterName - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeadingComma?.raw, - leadingComma.raw, - unexpectedBetweenLeadingCommaAndName?.raw, - name.raw, - unexpectedAfterName?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.designatedType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1547,6 +1482,7 @@ public struct DesignatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? { @@ -1647,33 +1583,23 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeKey), + Syntax(key), + Syntax(unexpectedBetweenKeyAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedBetweenValueAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeKey, - key, - unexpectedBetweenKeyAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedBetweenValueAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeKey?.raw, - key.raw, - unexpectedBetweenKeyAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.dictionaryElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1681,6 +1607,7 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeKey: UnexpectedNodesSyntax? { @@ -1899,29 +1826,21 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndContent), + Syntax(content), + Syntax(unexpectedBetweenContentAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedAfterRightSquare) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndContent, - content, - unexpectedBetweenContentAndRightSquare, - rightSquare, - unexpectedAfterRightSquare - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndContent?.raw, - content.raw, - unexpectedBetweenContentAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.dictionaryExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1929,6 +1848,7 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { @@ -2049,37 +1969,25 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndKey), + Syntax(key), + Syntax(unexpectedBetweenKeyAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedBetweenValueAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedAfterRightSquare) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndKey, - key, - unexpectedBetweenKeyAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedBetweenValueAndRightSquare, - rightSquare, - unexpectedAfterRightSquare - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndKey?.raw, - key.raw, - unexpectedBetweenKeyAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.dictionaryType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2087,6 +1995,7 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { @@ -2248,25 +2157,19 @@ public struct DifferentiabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeArgument), + Syntax(argument), + Syntax(unexpectedBetweenArgumentAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeArgument, - argument, - unexpectedBetweenArgumentAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeArgument?.raw, - argument.raw, - unexpectedBetweenArgumentAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.differentiabilityArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2274,6 +2177,7 @@ public struct DifferentiabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeArgument: UnexpectedNodesSyntax? { @@ -2378,29 +2282,21 @@ public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.differentiabilityArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2408,6 +2304,7 @@ public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -2465,7 +2362,7 @@ public struct DifferentiabilityArgumentsSyntax: SyntaxProtocol, SyntaxHashable, collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityArgumentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2641,29 +2538,21 @@ public struct DifferentiabilityWithRespectToArgumentSyntax: SyntaxProtocol, Synt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWrtLabel), + Syntax(wrtLabel), + Syntax(unexpectedBetweenWrtLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndArguments), + Syntax(arguments), + Syntax(unexpectedAfterArguments) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWrtLabel, - wrtLabel, - unexpectedBetweenWrtLabelAndColon, - colon, - unexpectedBetweenColonAndArguments, - arguments, - unexpectedAfterArguments - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWrtLabel?.raw, - wrtLabel.raw, - unexpectedBetweenWrtLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndArguments?.raw, - arguments.raw, - unexpectedAfterArguments?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.differentiabilityWithRespectToArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2671,6 +2560,7 @@ public struct DifferentiabilityWithRespectToArgumentSyntax: SyntaxProtocol, Synt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? { @@ -2806,37 +2696,25 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeKindSpecifier), + Syntax(kindSpecifier), + Syntax(unexpectedBetweenKindSpecifierAndKindSpecifierComma), + Syntax(kindSpecifierComma), + Syntax(unexpectedBetweenKindSpecifierCommaAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndArgumentsComma), + Syntax(argumentsComma), + Syntax(unexpectedBetweenArgumentsCommaAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedAfterGenericWhereClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeKindSpecifier, - kindSpecifier, - unexpectedBetweenKindSpecifierAndKindSpecifierComma, - kindSpecifierComma, - unexpectedBetweenKindSpecifierCommaAndArguments, - arguments, - unexpectedBetweenArgumentsAndArgumentsComma, - argumentsComma, - unexpectedBetweenArgumentsCommaAndGenericWhereClause, - genericWhereClause, - unexpectedAfterGenericWhereClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeKindSpecifier?.raw, - kindSpecifier?.raw, - unexpectedBetweenKindSpecifierAndKindSpecifierComma?.raw, - kindSpecifierComma?.raw, - unexpectedBetweenKindSpecifierCommaAndArguments?.raw, - arguments?.raw, - unexpectedBetweenArgumentsAndArgumentsComma?.raw, - argumentsComma?.raw, - unexpectedBetweenArgumentsCommaAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedAfterGenericWhereClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.differentiableAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2844,6 +2722,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeKindSpecifier: UnexpectedNodesSyntax? { @@ -3019,13 +2898,13 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeWildcard), Syntax(wildcard), Syntax(unexpectedAfterWildcard)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWildcard, wildcard, unexpectedAfterWildcard))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeWildcard?.raw, wildcard.raw, unexpectedAfterWildcard?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.discardAssignmentExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3033,6 +2912,7 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWildcard: UnexpectedNodesSyntax? { @@ -3097,25 +2977,19 @@ public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDiscardKeyword), + Syntax(discardKeyword), + Syntax(unexpectedBetweenDiscardKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDiscardKeyword, - discardKeyword, - unexpectedBetweenDiscardKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDiscardKeyword?.raw, - discardKeyword.raw, - unexpectedBetweenDiscardKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.discardStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3123,6 +2997,7 @@ public struct DiscardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDiscardKeyword: UnexpectedNodesSyntax? { @@ -3241,29 +3116,21 @@ public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDoKeyword), + Syntax(doKeyword), + Syntax(unexpectedBetweenDoKeywordAndBody), + Syntax(body), + Syntax(unexpectedBetweenBodyAndCatchClauses), + Syntax(catchClauses), + Syntax(unexpectedAfterCatchClauses) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDoKeyword, - doKeyword, - unexpectedBetweenDoKeywordAndBody, - body, - unexpectedBetweenBodyAndCatchClauses, - catchClauses, - unexpectedAfterCatchClauses - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDoKeyword?.raw, - doKeyword.raw, - unexpectedBetweenDoKeywordAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndCatchClauses?.raw, - catchClauses.raw, - unexpectedAfterCatchClauses?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.doExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3271,6 +3138,7 @@ public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? { @@ -3345,7 +3213,7 @@ public struct DoExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3413,33 +3281,23 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDoKeyword), + Syntax(doKeyword), + Syntax(unexpectedBetweenDoKeywordAndThrowsClause), + Syntax(throwsClause), + Syntax(unexpectedBetweenThrowsClauseAndBody), + Syntax(body), + Syntax(unexpectedBetweenBodyAndCatchClauses), + Syntax(catchClauses), + Syntax(unexpectedAfterCatchClauses) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDoKeyword, - doKeyword, - unexpectedBetweenDoKeywordAndThrowsClause, - throwsClause, - unexpectedBetweenThrowsClauseAndBody, - body, - unexpectedBetweenBodyAndCatchClauses, - catchClauses, - unexpectedAfterCatchClauses - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDoKeyword?.raw, - doKeyword.raw, - unexpectedBetweenDoKeywordAndThrowsClause?.raw, - throwsClause?.raw, - unexpectedBetweenThrowsClauseAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndCatchClauses?.raw, - catchClauses.raw, - unexpectedAfterCatchClauses?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.doStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3447,6 +3305,7 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? { @@ -3540,7 +3399,7 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntaxN collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3696,33 +3555,23 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedBetweenValueAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedBetweenValueAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.documentationAttributeArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3730,6 +3579,7 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -3877,29 +3727,21 @@ public struct DynamicReplacementAttributeArgumentsSyntax: SyntaxProtocol, Syntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeForLabel), + Syntax(forLabel), + Syntax(unexpectedBetweenForLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndDeclName), + Syntax(declName), + Syntax(unexpectedAfterDeclName) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeForLabel, - forLabel, - unexpectedBetweenForLabelAndColon, - colon, - unexpectedBetweenColonAndDeclName, - declName, - unexpectedAfterDeclName - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeForLabel?.raw, - forLabel.raw, - unexpectedBetweenForLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndDeclName?.raw, - declName.raw, - unexpectedAfterDeclName?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.dynamicReplacementAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3907,6 +3749,7 @@ public struct DynamicReplacementAttributeArgumentsSyntax: SyntaxProtocol, Syntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeForLabel: UnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift index 0d336fd635a..04c92dffe23 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift @@ -51,29 +51,21 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndPlaceholder), + Syntax(placeholder), + Syntax(unexpectedAfterPlaceholder) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndPlaceholder, - placeholder, - unexpectedAfterPlaceholder - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndPlaceholder?.raw, - placeholder.raw, - unexpectedAfterPlaceholder?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.editorPlaceholderDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -81,6 +73,7 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -117,7 +110,7 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _ collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -163,7 +156,7 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _ collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -246,13 +239,13 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePlaceholder), Syntax(placeholder), Syntax(unexpectedAfterPlaceholder)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.editorPlaceholderExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -260,6 +253,7 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { @@ -336,33 +330,23 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndCaseKeyword), + Syntax(caseKeyword), + Syntax(unexpectedBetweenCaseKeywordAndElements), + Syntax(elements), + Syntax(unexpectedAfterElements) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndCaseKeyword, - caseKeyword, - unexpectedBetweenCaseKeywordAndElements, - elements, - unexpectedAfterElements - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndElements?.raw, - elements.raw, - unexpectedAfterElements?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.enumCaseDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -370,6 +354,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -406,7 +391,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -452,7 +437,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -521,7 +506,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -600,33 +585,23 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndParameterClause), + Syntax(parameterClause), + Syntax(unexpectedBetweenParameterClauseAndRawValue), + Syntax(rawValue), + Syntax(unexpectedBetweenRawValueAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndParameterClause, - parameterClause, - unexpectedBetweenParameterClauseAndRawValue, - rawValue, - unexpectedBetweenRawValueAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndParameterClause?.raw, - parameterClause?.raw, - unexpectedBetweenParameterClauseAndRawValue?.raw, - rawValue?.raw, - unexpectedBetweenRawValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.enumCaseElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -634,6 +609,7 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -781,29 +757,21 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndParameters), + Syntax(parameters), + Syntax(unexpectedBetweenParametersAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndParameters, - parameters, - unexpectedBetweenParametersAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndParameters?.raw, - parameters.raw, - unexpectedBetweenParametersAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.enumCaseParameterClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -811,6 +779,7 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -870,7 +839,7 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -977,45 +946,29 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndFirstName), + Syntax(firstName), + Syntax(unexpectedBetweenFirstNameAndSecondName), + Syntax(secondName), + Syntax(unexpectedBetweenSecondNameAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndDefaultValue), + Syntax(defaultValue), + Syntax(unexpectedBetweenDefaultValueAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeModifiers, - modifiers, - unexpectedBetweenModifiersAndFirstName, - firstName, - unexpectedBetweenFirstNameAndSecondName, - secondName, - unexpectedBetweenSecondNameAndColon, - colon, - unexpectedBetweenColonAndType, - type, - unexpectedBetweenTypeAndDefaultValue, - defaultValue, - unexpectedBetweenDefaultValueAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndFirstName?.raw, - firstName?.raw, - unexpectedBetweenFirstNameAndSecondName?.raw, - secondName?.raw, - unexpectedBetweenSecondNameAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndType?.raw, - type.raw, - unexpectedBetweenTypeAndDefaultValue?.raw, - defaultValue?.raw, - unexpectedBetweenDefaultValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.enumCaseParameter, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1023,6 +976,7 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeModifiers: UnexpectedNodesSyntax? { @@ -1058,7 +1012,7 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1285,49 +1239,31 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndEnumKeyword), + Syntax(enumKeyword), + Syntax(unexpectedBetweenEnumKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndMemberBlock), + Syntax(memberBlock), + Syntax(unexpectedAfterMemberBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndEnumKeyword, - enumKeyword, - unexpectedBetweenEnumKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndEnumKeyword?.raw, - enumKeyword.raw, - unexpectedBetweenEnumKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.enumDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1335,6 +1271,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -1371,7 +1308,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1417,7 +1354,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1619,29 +1556,21 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLanguage), + Syntax(language), + Syntax(unexpectedBetweenLanguageAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndCxxName), + Syntax(cxxName), + Syntax(unexpectedAfterCxxName) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLanguage, - language, - unexpectedBetweenLanguageAndComma, - comma, - unexpectedBetweenCommaAndCxxName, - cxxName, - unexpectedAfterCxxName - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLanguage?.raw, - language.raw, - unexpectedBetweenLanguageAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndCxxName?.raw, - cxxName?.raw, - unexpectedAfterCxxName?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.exposeAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1649,6 +1578,7 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLanguage: UnexpectedNodesSyntax? { @@ -1768,13 +1698,13 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeExpression), Syntax(expression), Syntax(unexpectedAfterExpression)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeExpression?.raw, expression.raw, unexpectedAfterExpression?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.expressionPattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1782,6 +1712,7 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -1860,37 +1791,25 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBackslash), + Syntax(backslash), + Syntax(unexpectedBetweenBackslashAndPounds), + Syntax(pounds), + Syntax(unexpectedBetweenPoundsAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndExpressions), + Syntax(expressions), + Syntax(unexpectedBetweenExpressionsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBackslash, - backslash, - unexpectedBetweenBackslashAndPounds, - pounds, - unexpectedBetweenPoundsAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndExpressions, - expressions, - unexpectedBetweenExpressionsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBackslash?.raw, - backslash.raw, - unexpectedBetweenBackslashAndPounds?.raw, - pounds?.raw, - unexpectedBetweenPoundsAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndExpressions?.raw, - expressions.raw, - unexpectedBetweenExpressionsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.expressionSegment, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1898,6 +1817,7 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { @@ -1996,7 +1916,7 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2079,13 +1999,13 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeExpression), Syntax(expression), Syntax(unexpectedAfterExpression)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeExpression?.raw, expression.raw, unexpectedAfterExpression?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.expressionStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2093,6 +2013,7 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -2188,45 +2109,29 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndExtensionKeyword), + Syntax(extensionKeyword), + Syntax(unexpectedBetweenExtensionKeywordAndExtendedType), + Syntax(extendedType), + Syntax(unexpectedBetweenExtendedTypeAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndMemberBlock), + Syntax(memberBlock), + Syntax(unexpectedAfterMemberBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndExtensionKeyword, - extensionKeyword, - unexpectedBetweenExtensionKeywordAndExtendedType, - extendedType, - unexpectedBetweenExtendedTypeAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndExtensionKeyword?.raw, - extensionKeyword.raw, - unexpectedBetweenExtensionKeywordAndExtendedType?.raw, - extendedType.raw, - unexpectedBetweenExtendedTypeAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.extensionDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2234,6 +2139,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2278,7 +2184,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2324,7 +2230,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2489,13 +2395,13 @@ public struct FallThroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafSt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeFallthroughKeyword), Syntax(fallthroughKeyword), Syntax(unexpectedAfterFallthroughKeyword)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFallthroughKeyword, fallthroughKeyword, unexpectedAfterFallthroughKeyword))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeFallthroughKeyword?.raw, fallthroughKeyword.raw, unexpectedAfterFallthroughKeyword?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.fallThroughStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2503,6 +2409,7 @@ public struct FallThroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafSt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? { @@ -2564,13 +2471,13 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeLiteral), Syntax(literal), Syntax(unexpectedAfterLiteral)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLiteral, literal, unexpectedAfterLiteral))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeLiteral?.raw, literal.raw, unexpectedAfterLiteral?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.floatLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2578,6 +2485,7 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLiteral: UnexpectedNodesSyntax? { @@ -2666,57 +2574,35 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeForKeyword), + Syntax(forKeyword), + Syntax(unexpectedBetweenForKeywordAndTryKeyword), + Syntax(tryKeyword), + Syntax(unexpectedBetweenTryKeywordAndAwaitKeyword), + Syntax(awaitKeyword), + Syntax(unexpectedBetweenAwaitKeywordAndCaseKeyword), + Syntax(caseKeyword), + Syntax(unexpectedBetweenCaseKeywordAndPattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndTypeAnnotation), + Syntax(typeAnnotation), + Syntax(unexpectedBetweenTypeAnnotationAndInKeyword), + Syntax(inKeyword), + Syntax(unexpectedBetweenInKeywordAndSequence), + Syntax(sequence), + Syntax(unexpectedBetweenSequenceAndWhereClause), + Syntax(whereClause), + Syntax(unexpectedBetweenWhereClauseAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeForKeyword, - forKeyword, - unexpectedBetweenForKeywordAndTryKeyword, - tryKeyword, - unexpectedBetweenTryKeywordAndAwaitKeyword, - awaitKeyword, - unexpectedBetweenAwaitKeywordAndCaseKeyword, - caseKeyword, - unexpectedBetweenCaseKeywordAndPattern, - pattern, - unexpectedBetweenPatternAndTypeAnnotation, - typeAnnotation, - unexpectedBetweenTypeAnnotationAndInKeyword, - inKeyword, - unexpectedBetweenInKeywordAndSequence, - sequence, - unexpectedBetweenSequenceAndWhereClause, - whereClause, - unexpectedBetweenWhereClauseAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeForKeyword?.raw, - forKeyword.raw, - unexpectedBetweenForKeywordAndTryKeyword?.raw, - tryKeyword?.raw, - unexpectedBetweenTryKeywordAndAwaitKeyword?.raw, - awaitKeyword?.raw, - unexpectedBetweenAwaitKeywordAndCaseKeyword?.raw, - caseKeyword?.raw, - unexpectedBetweenCaseKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInKeyword?.raw, - inKeyword.raw, - unexpectedBetweenInKeywordAndSequence?.raw, - sequence.raw, - unexpectedBetweenSequenceAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndBody?.raw, - body.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.forStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2724,6 +2610,7 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeForKeyword: UnexpectedNodesSyntax? { @@ -2984,25 +2871,19 @@ public struct ForceUnwrapExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndExclamationMark), + Syntax(exclamationMark), + Syntax(unexpectedAfterExclamationMark) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndExclamationMark, - exclamationMark, - unexpectedAfterExclamationMark - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndExclamationMark?.raw, - exclamationMark.raw, - unexpectedAfterExclamationMark?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.forceUnwrapExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3010,6 +2891,7 @@ public struct ForceUnwrapExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -3110,41 +2992,27 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCalledExpression), + Syntax(calledExpression), + Syntax(unexpectedBetweenCalledExpressionAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedBetweenRightParenAndTrailingClosure), + Syntax(trailingClosure), + Syntax(unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures), + Syntax(additionalTrailingClosures), + Syntax(unexpectedAfterAdditionalTrailingClosures) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCalledExpression, - calledExpression, - unexpectedBetweenCalledExpressionAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedBetweenRightParenAndTrailingClosure, - trailingClosure, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, - additionalTrailingClosures, - unexpectedAfterAdditionalTrailingClosures - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCalledExpression?.raw, - calledExpression.raw, - unexpectedBetweenCalledExpressionAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen?.raw, - unexpectedBetweenRightParenAndTrailingClosure?.raw, - trailingClosure?.raw, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, - additionalTrailingClosures.raw, - unexpectedAfterAdditionalTrailingClosures?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionCallExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3152,6 +3020,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? { @@ -3226,7 +3095,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3310,7 +3179,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3423,49 +3292,31 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndFuncKeyword), + Syntax(funcKeyword), + Syntax(unexpectedBetweenFuncKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndSignature), + Syntax(signature), + Syntax(unexpectedBetweenSignatureAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndFuncKeyword, - funcKeyword, - unexpectedBetweenFuncKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndSignature, - signature, - unexpectedBetweenSignatureAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndFuncKeyword?.raw, - funcKeyword.raw, - unexpectedBetweenFuncKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndSignature?.raw, - signature.raw, - unexpectedBetweenSignatureAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndBody?.raw, - body?.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3473,6 +3324,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -3509,7 +3361,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3555,7 +3407,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3758,25 +3610,19 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAsyncSpecifier), + Syntax(asyncSpecifier), + Syntax(unexpectedBetweenAsyncSpecifierAndThrowsClause), + Syntax(throwsClause), + Syntax(unexpectedAfterThrowsClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAsyncSpecifier, - asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsClause, - throwsClause, - unexpectedAfterThrowsClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAsyncSpecifier?.raw, - asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw, - throwsClause?.raw, - unexpectedAfterThrowsClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionEffectSpecifiers, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3784,6 +3630,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { @@ -3885,29 +3732,21 @@ public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndParameters), + Syntax(parameters), + Syntax(unexpectedBetweenParametersAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndParameters, - parameters, - unexpectedBetweenParametersAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndParameters?.raw, - parameters.raw, - unexpectedBetweenParametersAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionParameterClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3915,6 +3754,7 @@ public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -3971,7 +3811,7 @@ public struct FunctionParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Le collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.functionParameterList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4089,53 +3929,33 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndFirstName), + Syntax(firstName), + Syntax(unexpectedBetweenFirstNameAndSecondName), + Syntax(secondName), + Syntax(unexpectedBetweenSecondNameAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndEllipsis), + Syntax(ellipsis), + Syntax(unexpectedBetweenEllipsisAndDefaultValue), + Syntax(defaultValue), + Syntax(unexpectedBetweenDefaultValueAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndFirstName, - firstName, - unexpectedBetweenFirstNameAndSecondName, - secondName, - unexpectedBetweenSecondNameAndColon, - colon, - unexpectedBetweenColonAndType, - type, - unexpectedBetweenTypeAndEllipsis, - ellipsis, - unexpectedBetweenEllipsisAndDefaultValue, - defaultValue, - unexpectedBetweenDefaultValueAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndFirstName?.raw, - firstName.raw, - unexpectedBetweenFirstNameAndSecondName?.raw, - secondName?.raw, - unexpectedBetweenSecondNameAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndType?.raw, - type.raw, - unexpectedBetweenTypeAndEllipsis?.raw, - ellipsis?.raw, - unexpectedBetweenEllipsisAndDefaultValue?.raw, - defaultValue?.raw, - unexpectedBetweenDefaultValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionParameter, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4143,6 +3963,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -4179,7 +4000,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4225,7 +4046,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4469,29 +4290,21 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeParameterClause), + Syntax(parameterClause), + Syntax(unexpectedBetweenParameterClauseAndEffectSpecifiers), + Syntax(effectSpecifiers), + Syntax(unexpectedBetweenEffectSpecifiersAndReturnClause), + Syntax(returnClause), + Syntax(unexpectedAfterReturnClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeParameterClause, - parameterClause, - unexpectedBetweenParameterClauseAndEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndReturnClause, - returnClause, - unexpectedAfterReturnClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeParameterClause?.raw, - parameterClause.raw, - unexpectedBetweenParameterClauseAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndReturnClause?.raw, - returnClause?.raw, - unexpectedAfterReturnClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionSignature, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4499,6 +4312,7 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeParameterClause: UnexpectedNodesSyntax? { @@ -4616,37 +4430,25 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndParameters), + Syntax(parameters), + Syntax(unexpectedBetweenParametersAndRightParen), + Syntax(rightParen), + Syntax(unexpectedBetweenRightParenAndEffectSpecifiers), + Syntax(effectSpecifiers), + Syntax(unexpectedBetweenEffectSpecifiersAndReturnClause), + Syntax(returnClause), + Syntax(unexpectedAfterReturnClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndParameters, - parameters, - unexpectedBetweenParametersAndRightParen, - rightParen, - unexpectedBetweenRightParenAndEffectSpecifiers, - effectSpecifiers, - unexpectedBetweenEffectSpecifiersAndReturnClause, - returnClause, - unexpectedAfterReturnClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndParameters?.raw, - parameters.raw, - unexpectedBetweenParametersAndRightParen?.raw, - rightParen.raw, - unexpectedBetweenRightParenAndEffectSpecifiers?.raw, - effectSpecifiers?.raw, - unexpectedBetweenEffectSpecifiersAndReturnClause?.raw, - returnClause.raw, - unexpectedAfterReturnClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.functionType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4654,6 +4456,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -4710,7 +4513,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift index 2a4290515da..baeccade2f3 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift @@ -53,29 +53,21 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftAngle), + Syntax(leftAngle), + Syntax(unexpectedBetweenLeftAngleAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightAngle), + Syntax(rightAngle), + Syntax(unexpectedAfterRightAngle) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftAngle, - leftAngle, - unexpectedBetweenLeftAngleAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightAngle, - rightAngle, - unexpectedAfterRightAngle - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftAngle?.raw, - leftAngle.raw, - unexpectedBetweenLeftAngleAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightAngle?.raw, - rightAngle.raw, - unexpectedAfterRightAngle?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericArgumentClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -83,6 +75,7 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftAngle: UnexpectedNodesSyntax? { @@ -139,7 +132,7 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.genericArgumentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -225,25 +218,19 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeArgument), + Syntax(argument), + Syntax(unexpectedBetweenArgumentAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeArgument, - argument, - unexpectedBetweenArgumentAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeArgument?.raw, - argument.raw, - unexpectedBetweenArgumentAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -251,6 +238,7 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeArgument: UnexpectedNodesSyntax? { @@ -364,33 +352,23 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftAngle), + Syntax(leftAngle), + Syntax(unexpectedBetweenLeftAngleAndParameters), + Syntax(parameters), + Syntax(unexpectedBetweenParametersAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndRightAngle), + Syntax(rightAngle), + Syntax(unexpectedAfterRightAngle) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftAngle, - leftAngle, - unexpectedBetweenLeftAngleAndParameters, - parameters, - unexpectedBetweenParametersAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndRightAngle, - rightAngle, - unexpectedAfterRightAngle - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftAngle?.raw, - leftAngle.raw, - unexpectedBetweenLeftAngleAndParameters?.raw, - parameters.raw, - unexpectedBetweenParametersAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndRightAngle?.raw, - rightAngle.raw, - unexpectedAfterRightAngle?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericParameterClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -398,6 +376,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftAngle: UnexpectedNodesSyntax? { @@ -457,7 +436,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.genericParameterList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -578,41 +557,27 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndEachKeyword), + Syntax(eachKeyword), + Syntax(unexpectedBetweenEachKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndInheritedType), + Syntax(inheritedType), + Syntax(unexpectedBetweenInheritedTypeAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndEachKeyword, - eachKeyword, - unexpectedBetweenEachKeywordAndName, - name, - unexpectedBetweenNameAndColon, - colon, - unexpectedBetweenColonAndInheritedType, - inheritedType, - unexpectedBetweenInheritedTypeAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndEachKeyword?.raw, - eachKeyword?.raw, - unexpectedBetweenEachKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndInheritedType?.raw, - inheritedType?.raw, - unexpectedBetweenInheritedTypeAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericParameter, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -620,6 +585,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -655,7 +621,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -943,25 +909,19 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeRequirement), + Syntax(requirement), + Syntax(unexpectedBetweenRequirementAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeRequirement, - requirement, - unexpectedBetweenRequirementAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeRequirement?.raw, - requirement.raw, - unexpectedBetweenRequirementAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericRequirement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -969,6 +929,7 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeRequirement: UnexpectedNodesSyntax? { @@ -1057,25 +1018,19 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndGenericArgumentClause), + Syntax(genericArgumentClause), + Syntax(unexpectedAfterGenericArgumentClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndGenericArgumentClause, - genericArgumentClause, - unexpectedAfterGenericArgumentClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndGenericArgumentClause?.raw, - genericArgumentClause.raw, - unexpectedAfterGenericArgumentClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericSpecializationExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1083,6 +1038,7 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -1190,25 +1146,19 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWhereKeyword), + Syntax(whereKeyword), + Syntax(unexpectedBetweenWhereKeywordAndRequirements), + Syntax(requirements), + Syntax(unexpectedAfterRequirements) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWhereKeyword, - whereKeyword, - unexpectedBetweenWhereKeywordAndRequirements, - requirements, - unexpectedAfterRequirements - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWhereKeyword?.raw, - whereKeyword.raw, - unexpectedBetweenWhereKeywordAndRequirements?.raw, - requirements.raw, - unexpectedAfterRequirements?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.genericWhereClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1216,6 +1166,7 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? { @@ -1275,7 +1226,7 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.genericRequirementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1340,33 +1291,23 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeGuardKeyword), + Syntax(guardKeyword), + Syntax(unexpectedBetweenGuardKeywordAndConditions), + Syntax(conditions), + Syntax(unexpectedBetweenConditionsAndElseKeyword), + Syntax(elseKeyword), + Syntax(unexpectedBetweenElseKeywordAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeGuardKeyword, - guardKeyword, - unexpectedBetweenGuardKeywordAndConditions, - conditions, - unexpectedBetweenConditionsAndElseKeyword, - elseKeyword, - unexpectedBetweenElseKeywordAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeGuardKeyword?.raw, - guardKeyword.raw, - unexpectedBetweenGuardKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndElseKeyword?.raw, - elseKeyword.raw, - unexpectedBetweenElseKeywordAndBody?.raw, - body.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.guardStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1374,6 +1315,7 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeGuardKeyword: UnexpectedNodesSyntax? { @@ -1430,7 +1372,7 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1540,13 +1482,13 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeIdentifier), Syntax(identifier), Syntax(unexpectedAfterIdentifier)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeIdentifier?.raw, identifier.raw, unexpectedAfterIdentifier?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.identifierPattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1554,6 +1496,7 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeIdentifier: UnexpectedNodesSyntax? { @@ -1623,25 +1566,19 @@ public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericArgumentClause), + Syntax(genericArgumentClause), + Syntax(unexpectedAfterGenericArgumentClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndGenericArgumentClause, - genericArgumentClause, - unexpectedAfterGenericArgumentClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedAfterGenericArgumentClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.identifierType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1649,6 +1586,7 @@ public struct IdentifierTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -1935,29 +1873,21 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePoundKeyword), + Syntax(poundKeyword), + Syntax(unexpectedBetweenPoundKeywordAndCondition), + Syntax(condition), + Syntax(unexpectedBetweenConditionAndElements), + Syntax(elements), + Syntax(unexpectedAfterElements) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePoundKeyword, - poundKeyword, - unexpectedBetweenPoundKeywordAndCondition, - condition, - unexpectedBetweenConditionAndElements, - elements, - unexpectedAfterElements - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePoundKeyword?.raw, - poundKeyword.raw, - unexpectedBetweenPoundKeywordAndCondition?.raw, - condition?.raw, - unexpectedBetweenConditionAndElements?.raw, - elements?.raw, - unexpectedAfterElements?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.ifConfigClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1965,6 +1895,7 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? { @@ -2082,25 +2013,19 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeClauses), + Syntax(clauses), + Syntax(unexpectedBetweenClausesAndPoundEndif), + Syntax(poundEndif), + Syntax(unexpectedAfterPoundEndif) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeClauses, - clauses, - unexpectedBetweenClausesAndPoundEndif, - poundEndif, - unexpectedAfterPoundEndif - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeClauses?.raw, - clauses.raw, - unexpectedBetweenClausesAndPoundEndif?.raw, - poundEndif.raw, - unexpectedAfterPoundEndif?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.ifConfigDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2108,6 +2033,7 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeClauses: UnexpectedNodesSyntax? { @@ -2143,7 +2069,7 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.ifConfigClauseList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2318,37 +2244,25 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeIfKeyword), + Syntax(ifKeyword), + Syntax(unexpectedBetweenIfKeywordAndConditions), + Syntax(conditions), + Syntax(unexpectedBetweenConditionsAndBody), + Syntax(body), + Syntax(unexpectedBetweenBodyAndElseKeyword), + Syntax(elseKeyword), + Syntax(unexpectedBetweenElseKeywordAndElseBody), + Syntax(elseBody), + Syntax(unexpectedAfterElseBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeIfKeyword, - ifKeyword, - unexpectedBetweenIfKeywordAndConditions, - conditions, - unexpectedBetweenConditionsAndBody, - body, - unexpectedBetweenBodyAndElseKeyword, - elseKeyword, - unexpectedBetweenElseKeywordAndElseBody, - elseBody, - unexpectedAfterElseBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeIfKeyword?.raw, - ifKeyword.raw, - unexpectedBetweenIfKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndElseKeyword?.raw, - elseKeyword?.raw, - unexpectedBetweenElseKeywordAndElseBody?.raw, - elseBody?.raw, - unexpectedAfterElseBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.ifExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2356,6 +2270,7 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? { @@ -2412,7 +2327,7 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2546,29 +2461,21 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndDeclName), + Syntax(declName), + Syntax(unexpectedAfterDeclName) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeType, - type, - unexpectedBetweenTypeAndComma, - comma, - unexpectedBetweenCommaAndDeclName, - declName, - unexpectedAfterDeclName - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndDeclName?.raw, - declName.raw, - unexpectedAfterDeclName?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.implementsAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2576,6 +2483,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeType: UnexpectedNodesSyntax? { @@ -2688,25 +2596,19 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWrappedType), + Syntax(wrappedType), + Syntax(unexpectedBetweenWrappedTypeAndExclamationMark), + Syntax(exclamationMark), + Syntax(unexpectedAfterExclamationMark) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWrappedType, - wrappedType, - unexpectedBetweenWrappedTypeAndExclamationMark, - exclamationMark, - unexpectedAfterExclamationMark - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWrappedType?.raw, - wrappedType.raw, - unexpectedBetweenWrappedTypeAndExclamationMark?.raw, - exclamationMark.raw, - unexpectedAfterExclamationMark?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.implicitlyUnwrappedOptionalType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2714,6 +2616,7 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWrappedType: UnexpectedNodesSyntax? { @@ -2824,37 +2727,25 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndImportKeyword), + Syntax(importKeyword), + Syntax(unexpectedBetweenImportKeywordAndImportKindSpecifier), + Syntax(importKindSpecifier), + Syntax(unexpectedBetweenImportKindSpecifierAndPath), + Syntax(path), + Syntax(unexpectedAfterPath) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndImportKeyword, - importKeyword, - unexpectedBetweenImportKeywordAndImportKindSpecifier, - importKindSpecifier, - unexpectedBetweenImportKindSpecifierAndPath, - path, - unexpectedAfterPath - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndImportKeyword?.raw, - importKeyword.raw, - unexpectedBetweenImportKeywordAndImportKindSpecifier?.raw, - importKindSpecifier?.raw, - unexpectedBetweenImportKindSpecifierAndPath?.raw, - path.raw, - unexpectedAfterPath?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.importDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2862,6 +2753,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2898,7 +2790,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2944,7 +2836,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3047,7 +2939,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.importPathComponentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3116,25 +3008,19 @@ public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndTrailingPeriod), + Syntax(trailingPeriod), + Syntax(unexpectedAfterTrailingPeriod) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndTrailingPeriod, - trailingPeriod, - unexpectedAfterTrailingPeriod - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingPeriod?.raw, - trailingPeriod?.raw, - unexpectedAfterTrailingPeriod?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.importPathComponent, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3142,6 +3028,7 @@ public struct ImportPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -3239,25 +3126,19 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAmpersand), + Syntax(ampersand), + Syntax(unexpectedBetweenAmpersandAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAmpersand, - ampersand, - unexpectedBetweenAmpersandAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAmpersand?.raw, - ampersand.raw, - unexpectedBetweenAmpersandAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.inOutExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3265,6 +3146,7 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAmpersand: UnexpectedNodesSyntax? { @@ -3362,29 +3244,21 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftOperand), + Syntax(leftOperand), + Syntax(unexpectedBetweenLeftOperandAndOperator), + Syntax(`operator`), + Syntax(unexpectedBetweenOperatorAndRightOperand), + Syntax(rightOperand), + Syntax(unexpectedAfterRightOperand) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftOperand, - leftOperand, - unexpectedBetweenLeftOperandAndOperator, - `operator`, - unexpectedBetweenOperatorAndRightOperand, - rightOperand, - unexpectedAfterRightOperand - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftOperand?.raw, - leftOperand.raw, - unexpectedBetweenLeftOperandAndOperator?.raw, - `operator`.raw, - unexpectedBetweenOperatorAndRightOperand?.raw, - rightOperand.raw, - unexpectedAfterRightOperand?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.infixOperatorExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3392,6 +3266,7 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? { @@ -3507,25 +3382,19 @@ public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndInheritedTypes), + Syntax(inheritedTypes), + Syntax(unexpectedAfterInheritedTypes) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeColon, - colon, - unexpectedBetweenColonAndInheritedTypes, - inheritedTypes, - unexpectedAfterInheritedTypes - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndInheritedTypes?.raw, - inheritedTypes.raw, - unexpectedAfterInheritedTypes?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.inheritanceClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3533,6 +3402,7 @@ public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeColon: UnexpectedNodesSyntax? { @@ -3589,7 +3459,7 @@ public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.inheritedTypeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3652,25 +3522,19 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeType, - type, - unexpectedBetweenTypeAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.inheritedType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3678,6 +3542,7 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeType: UnexpectedNodesSyntax? { @@ -3776,25 +3641,19 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeEqual), + Syntax(equal), + Syntax(unexpectedBetweenEqualAndValue), + Syntax(value), + Syntax(unexpectedAfterValue) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeEqual, - equal, - unexpectedBetweenEqualAndValue, - value, - unexpectedAfterValue - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.initializerClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3802,6 +3661,7 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { @@ -3927,49 +3787,31 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndInitKeyword), + Syntax(initKeyword), + Syntax(unexpectedBetweenInitKeywordAndOptionalMark), + Syntax(optionalMark), + Syntax(unexpectedBetweenOptionalMarkAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndSignature), + Syntax(signature), + Syntax(unexpectedBetweenSignatureAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndInitKeyword, - initKeyword, - unexpectedBetweenInitKeywordAndOptionalMark, - optionalMark, - unexpectedBetweenOptionalMarkAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndSignature, - signature, - unexpectedBetweenSignatureAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndInitKeyword?.raw, - initKeyword.raw, - unexpectedBetweenInitKeywordAndOptionalMark?.raw, - optionalMark?.raw, - unexpectedBetweenOptionalMarkAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndSignature?.raw, - signature.raw, - unexpectedBetweenSignatureAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndBody?.raw, - body?.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.initializerDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3977,6 +3819,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -4013,7 +3856,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4059,7 +3902,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDe collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4251,13 +4094,13 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeLiteral), Syntax(literal), Syntax(unexpectedAfterLiteral)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeLiteral, literal, unexpectedAfterLiteral))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeLiteral?.raw, literal.raw, unexpectedAfterLiteral?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.integerLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4265,6 +4108,7 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLiteral: UnexpectedNodesSyntax? { @@ -4346,29 +4190,21 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndIsKeyword), + Syntax(isKeyword), + Syntax(unexpectedBetweenIsKeywordAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndIsKeyword, - isKeyword, - unexpectedBetweenIsKeywordAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndIsKeyword?.raw, - isKeyword.raw, - unexpectedBetweenIsKeywordAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.isExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4376,6 +4212,7 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -4488,25 +4325,19 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafP trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeIsKeyword), + Syntax(isKeyword), + Syntax(unexpectedBetweenIsKeywordAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeIsKeyword, - isKeyword, - unexpectedBetweenIsKeywordAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeIsKeyword?.raw, - isKeyword.raw, - unexpectedBetweenIsKeywordAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.isTypePattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4514,6 +4345,7 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafP ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeIsKeyword: UnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift index d4f30a1e54b..5df069607a3 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift @@ -162,25 +162,19 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePeriod), + Syntax(period), + Syntax(unexpectedBetweenPeriodAndComponent), + Syntax(component), + Syntax(unexpectedAfterComponent) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePeriod, - period, - unexpectedBetweenPeriodAndComponent, - component, - unexpectedAfterComponent - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePeriod?.raw, - period?.raw, - unexpectedBetweenPeriodAndComponent?.raw, - component.raw, - unexpectedAfterComponent?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.keyPathComponent, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -188,6 +182,7 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePeriod: UnexpectedNodesSyntax? { @@ -287,29 +282,21 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBackslash), + Syntax(backslash), + Syntax(unexpectedBetweenBackslashAndRoot), + Syntax(root), + Syntax(unexpectedBetweenRootAndComponents), + Syntax(components), + Syntax(unexpectedAfterComponents) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBackslash, - backslash, - unexpectedBetweenBackslashAndRoot, - root, - unexpectedBetweenRootAndComponents, - components, - unexpectedAfterComponents - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBackslash?.raw, - backslash.raw, - unexpectedBetweenBackslashAndRoot?.raw, - root?.raw, - unexpectedBetweenRootAndComponents?.raw, - components.raw, - unexpectedAfterComponents?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.keyPathExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -317,6 +304,7 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBackslash: UnexpectedNodesSyntax? { @@ -391,7 +379,7 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.keyPathComponentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -455,13 +443,13 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeQuestionOrExclamationMark), Syntax(questionOrExclamationMark), Syntax(unexpectedAfterQuestionOrExclamationMark)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeQuestionOrExclamationMark?.raw, questionOrExclamationMark.raw, unexpectedAfterQuestionOrExclamationMark?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.keyPathOptionalComponent, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -469,6 +457,7 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? { @@ -541,25 +530,19 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDeclName), + Syntax(declName), + Syntax(unexpectedBetweenDeclNameAndGenericArgumentClause), + Syntax(genericArgumentClause), + Syntax(unexpectedAfterGenericArgumentClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDeclName, - declName, - unexpectedBetweenDeclNameAndGenericArgumentClause, - genericArgumentClause, - unexpectedAfterGenericArgumentClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDeclName?.raw, - declName.raw, - unexpectedBetweenDeclNameAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedAfterGenericArgumentClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.keyPathPropertyComponent, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -567,6 +550,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDeclName: UnexpectedNodesSyntax? { @@ -661,29 +645,21 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedAfterRightSquare) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightSquare, - rightSquare, - unexpectedAfterRightSquare - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightSquare?.raw, - rightSquare.raw, - unexpectedAfterRightSquare?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.keyPathSubscriptComponent, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -691,6 +667,7 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? { @@ -747,7 +724,7 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable, _ collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -845,33 +822,23 @@ public struct LabeledExprSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndExpression, - expression, - unexpectedBetweenExpressionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label?.raw, - unexpectedBetweenLabelAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.labeledExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -879,6 +846,7 @@ public struct LabeledExprSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -1031,33 +999,23 @@ public struct LabeledSpecializeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedBetweenValueAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedBetweenValueAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedBetweenValueAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.labeledSpecializeArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1065,6 +1023,7 @@ public struct LabeledSpecializeArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -1215,29 +1174,21 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndStatement), + Syntax(statement), + Syntax(unexpectedAfterStatement) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndStatement, - statement, - unexpectedAfterStatement - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndStatement?.raw, - statement.raw, - unexpectedAfterStatement?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.labeledStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1245,6 +1196,7 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -1378,49 +1330,31 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndLayoutSpecifier), + Syntax(layoutSpecifier), + Syntax(unexpectedBetweenLayoutSpecifierAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndSize), + Syntax(size), + Syntax(unexpectedBetweenSizeAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndAlignment), + Syntax(alignment), + Syntax(unexpectedBetweenAlignmentAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeType, - type, - unexpectedBetweenTypeAndColon, - colon, - unexpectedBetweenColonAndLayoutSpecifier, - layoutSpecifier, - unexpectedBetweenLayoutSpecifierAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndSize, - size, - unexpectedBetweenSizeAndComma, - comma, - unexpectedBetweenCommaAndAlignment, - alignment, - unexpectedBetweenAlignmentAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeType?.raw, - type.raw, - unexpectedBetweenTypeAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndLayoutSpecifier?.raw, - layoutSpecifier.raw, - unexpectedBetweenLayoutSpecifierAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndSize?.raw, - size?.raw, - unexpectedBetweenSizeAndComma?.raw, - comma?.raw, - unexpectedBetweenCommaAndAlignment?.raw, - alignment?.raw, - unexpectedBetweenAlignmentAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.layoutRequirement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1428,6 +1362,7 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeType: UnexpectedNodesSyntax? { @@ -1674,25 +1609,19 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeParameter), + Syntax(parameter), + Syntax(unexpectedBetweenParameterAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeParameter, - parameter, - unexpectedBetweenParameterAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeParameter?.raw, - parameter.raw, - unexpectedBetweenParameterAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.lifetimeSpecifierArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1700,6 +1629,7 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeParameter: UnexpectedNodesSyntax? { @@ -1821,37 +1751,25 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDependsOnKeyword), + Syntax(dependsOnKeyword), + Syntax(unexpectedBetweenDependsOnKeywordAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndScopedKeyword), + Syntax(scopedKeyword), + Syntax(unexpectedBetweenScopedKeywordAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDependsOnKeyword, - dependsOnKeyword, - unexpectedBetweenDependsOnKeywordAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndScopedKeyword, - scopedKeyword, - unexpectedBetweenScopedKeywordAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDependsOnKeyword?.raw, - dependsOnKeyword.raw, - unexpectedBetweenDependsOnKeywordAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndScopedKeyword?.raw, - scopedKeyword?.raw, - unexpectedBetweenScopedKeywordAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.lifetimeTypeSpecifier, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1859,6 +1777,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? { @@ -1961,7 +1880,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.lifetimeSpecifierArgumentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2067,49 +1986,31 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndMacroKeyword), + Syntax(macroKeyword), + Syntax(unexpectedBetweenMacroKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndSignature), + Syntax(signature), + Syntax(unexpectedBetweenSignatureAndDefinition), + Syntax(definition), + Syntax(unexpectedBetweenDefinitionAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedAfterGenericWhereClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndMacroKeyword, - macroKeyword, - unexpectedBetweenMacroKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndSignature, - signature, - unexpectedBetweenSignatureAndDefinition, - definition, - unexpectedBetweenDefinitionAndGenericWhereClause, - genericWhereClause, - unexpectedAfterGenericWhereClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndMacroKeyword?.raw, - macroKeyword.raw, - unexpectedBetweenMacroKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndSignature?.raw, - signature.raw, - unexpectedBetweenSignatureAndDefinition?.raw, - definition?.raw, - unexpectedBetweenDefinitionAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedAfterGenericWhereClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.macroDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2117,6 +2018,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2152,7 +2054,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2197,7 +2099,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2411,57 +2313,35 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndPound), + Syntax(pound), + Syntax(unexpectedBetweenPoundAndMacroName), + Syntax(macroName), + Syntax(unexpectedBetweenMacroNameAndGenericArgumentClause), + Syntax(genericArgumentClause), + Syntax(unexpectedBetweenGenericArgumentClauseAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedBetweenRightParenAndTrailingClosure), + Syntax(trailingClosure), + Syntax(unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures), + Syntax(additionalTrailingClosures), + Syntax(unexpectedAfterAdditionalTrailingClosures) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndPound, - pound, - unexpectedBetweenPoundAndMacroName, - macroName, - unexpectedBetweenMacroNameAndGenericArgumentClause, - genericArgumentClause, - unexpectedBetweenGenericArgumentClauseAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedBetweenRightParenAndTrailingClosure, - trailingClosure, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, - additionalTrailingClosures, - unexpectedAfterAdditionalTrailingClosures - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndPound?.raw, - pound.raw, - unexpectedBetweenPoundAndMacroName?.raw, - macroName.raw, - unexpectedBetweenMacroNameAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedBetweenGenericArgumentClauseAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen?.raw, - unexpectedBetweenRightParenAndTrailingClosure?.raw, - trailingClosure?.raw, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, - additionalTrailingClosures.raw, - unexpectedAfterAdditionalTrailingClosures?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.macroExpansionDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2469,6 +2349,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2504,7 +2385,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2549,7 +2430,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2677,7 +2558,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2761,7 +2642,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2857,49 +2738,31 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePound), + Syntax(pound), + Syntax(unexpectedBetweenPoundAndMacroName), + Syntax(macroName), + Syntax(unexpectedBetweenMacroNameAndGenericArgumentClause), + Syntax(genericArgumentClause), + Syntax(unexpectedBetweenGenericArgumentClauseAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedBetweenRightParenAndTrailingClosure), + Syntax(trailingClosure), + Syntax(unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures), + Syntax(additionalTrailingClosures), + Syntax(unexpectedAfterAdditionalTrailingClosures) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePound, - pound, - unexpectedBetweenPoundAndMacroName, - macroName, - unexpectedBetweenMacroNameAndGenericArgumentClause, - genericArgumentClause, - unexpectedBetweenGenericArgumentClauseAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedBetweenRightParenAndTrailingClosure, - trailingClosure, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, - additionalTrailingClosures, - unexpectedAfterAdditionalTrailingClosures - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePound?.raw, - pound.raw, - unexpectedBetweenPoundAndMacroName?.raw, - macroName.raw, - unexpectedBetweenMacroNameAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedBetweenGenericArgumentClauseAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen?.raw, - unexpectedBetweenRightParenAndTrailingClosure?.raw, - trailingClosure?.raw, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, - additionalTrailingClosures.raw, - unexpectedAfterAdditionalTrailingClosures?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.macroExpansionExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2907,6 +2770,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePound: UnexpectedNodesSyntax? { @@ -3025,7 +2889,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3109,7 +2973,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3190,33 +3054,23 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCaseKeyword), + Syntax(caseKeyword), + Syntax(unexpectedBetweenCaseKeywordAndPattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndTypeAnnotation), + Syntax(typeAnnotation), + Syntax(unexpectedBetweenTypeAnnotationAndInitializer), + Syntax(initializer), + Syntax(unexpectedAfterInitializer) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCaseKeyword, - caseKeyword, - unexpectedBetweenCaseKeywordAndPattern, - pattern, - unexpectedBetweenPatternAndTypeAnnotation, - typeAnnotation, - unexpectedBetweenTypeAnnotationAndInitializer, - initializer, - unexpectedAfterInitializer - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer.raw, - unexpectedAfterInitializer?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.matchingPatternCondition, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3224,6 +3078,7 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { @@ -3359,29 +3214,21 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBase), + Syntax(base), + Syntax(unexpectedBetweenBaseAndPeriod), + Syntax(period), + Syntax(unexpectedBetweenPeriodAndDeclName), + Syntax(declName), + Syntax(unexpectedAfterDeclName) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBase, - base, - unexpectedBetweenBaseAndPeriod, - period, - unexpectedBetweenPeriodAndDeclName, - declName, - unexpectedAfterDeclName - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBase?.raw, - base?.raw, - unexpectedBetweenBaseAndPeriod?.raw, - period.raw, - unexpectedBetweenPeriodAndDeclName?.raw, - declName.raw, - unexpectedAfterDeclName?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.memberAccessExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3389,6 +3236,7 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBase: UnexpectedNodesSyntax? { @@ -3507,25 +3355,19 @@ public struct MemberBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDecl), + Syntax(decl), + Syntax(unexpectedBetweenDeclAndSemicolon), + Syntax(semicolon), + Syntax(unexpectedAfterSemicolon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDecl, - decl, - unexpectedBetweenDeclAndSemicolon, - semicolon, - unexpectedAfterSemicolon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDecl?.raw, - decl.raw, - unexpectedBetweenDeclAndSemicolon?.raw, - semicolon?.raw, - unexpectedAfterSemicolon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.memberBlockItem, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3533,6 +3375,7 @@ public struct MemberBlockItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDecl: UnexpectedNodesSyntax? { @@ -3636,29 +3479,21 @@ public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftBrace), + Syntax(leftBrace), + Syntax(unexpectedBetweenLeftBraceAndMembers), + Syntax(members), + Syntax(unexpectedBetweenMembersAndRightBrace), + Syntax(rightBrace), + Syntax(unexpectedAfterRightBrace) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndMembers, - members, - unexpectedBetweenMembersAndRightBrace, - rightBrace, - unexpectedAfterRightBrace - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndMembers?.raw, - members.raw, - unexpectedBetweenMembersAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.memberBlock, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3666,6 +3501,7 @@ public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? { @@ -3722,7 +3558,7 @@ public struct MemberBlockSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.memberBlockItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3810,33 +3646,23 @@ public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBaseType), + Syntax(baseType), + Syntax(unexpectedBetweenBaseTypeAndPeriod), + Syntax(period), + Syntax(unexpectedBetweenPeriodAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericArgumentClause), + Syntax(genericArgumentClause), + Syntax(unexpectedAfterGenericArgumentClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBaseType, - baseType, - unexpectedBetweenBaseTypeAndPeriod, - period, - unexpectedBetweenPeriodAndName, - name, - unexpectedBetweenNameAndGenericArgumentClause, - genericArgumentClause, - unexpectedAfterGenericArgumentClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBaseType?.raw, - baseType.raw, - unexpectedBetweenBaseTypeAndPeriod?.raw, - period.raw, - unexpectedBetweenPeriodAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericArgumentClause?.raw, - genericArgumentClause?.raw, - unexpectedAfterGenericArgumentClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.memberType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3844,6 +3670,7 @@ public struct MemberTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBaseType: UnexpectedNodesSyntax? { @@ -3980,29 +3807,21 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBaseType), + Syntax(baseType), + Syntax(unexpectedBetweenBaseTypeAndPeriod), + Syntax(period), + Syntax(unexpectedBetweenPeriodAndMetatypeSpecifier), + Syntax(metatypeSpecifier), + Syntax(unexpectedAfterMetatypeSpecifier) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBaseType, - baseType, - unexpectedBetweenBaseTypeAndPeriod, - period, - unexpectedBetweenPeriodAndMetatypeSpecifier, - metatypeSpecifier, - unexpectedAfterMetatypeSpecifier - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBaseType?.raw, - baseType.raw, - unexpectedBetweenBaseTypeAndPeriod?.raw, - period.raw, - unexpectedBetweenPeriodAndMetatypeSpecifier?.raw, - metatypeSpecifier.raw, - unexpectedAfterMetatypeSpecifier?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.metatypeType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4010,6 +3829,7 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBaseType: UnexpectedNodesSyntax? { @@ -4131,29 +3951,21 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndPlaceholder), + Syntax(placeholder), + Syntax(unexpectedAfterPlaceholder) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndPlaceholder, - placeholder, - unexpectedAfterPlaceholder - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndPlaceholder?.raw, - placeholder.raw, - unexpectedAfterPlaceholder?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.missingDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4161,6 +3973,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -4197,7 +4010,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSy collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4243,7 +4056,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSy collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4329,13 +4142,13 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePlaceholder), Syntax(placeholder), Syntax(unexpectedAfterPlaceholder)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.missingExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4343,6 +4156,7 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { @@ -4411,13 +4225,13 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePlaceholder), Syntax(placeholder), Syntax(unexpectedAfterPlaceholder)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.missingPattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4425,6 +4239,7 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { @@ -4493,13 +4308,13 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePlaceholder), Syntax(placeholder), Syntax(unexpectedAfterPlaceholder)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.missingStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4507,6 +4322,7 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { @@ -4575,13 +4391,13 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePlaceholder), Syntax(placeholder), Syntax(unexpectedAfterPlaceholder)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.missing, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4589,6 +4405,7 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { @@ -4657,13 +4474,13 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePlaceholder), Syntax(placeholder), Syntax(unexpectedAfterPlaceholder)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.missingType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4671,6 +4488,7 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { @@ -4746,29 +4564,21 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndClosure), + Syntax(closure), + Syntax(unexpectedAfterClosure) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndClosure, - closure, - unexpectedAfterClosure - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label.raw, - unexpectedBetweenLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndClosure?.raw, - closure.raw, - unexpectedAfterClosure?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.multipleTrailingClosureElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4776,6 +4586,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -4890,25 +4701,19 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeGenericParameterClause?.raw, - genericParameterClause.raw, - unexpectedBetweenGenericParameterClauseAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.namedOpaqueReturnType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4916,6 +4721,7 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeGenericParameterClause: UnexpectedNodesSyntax? { @@ -4999,13 +4805,13 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeNilKeyword), Syntax(nilKeyword), Syntax(unexpectedAfterNilKeyword)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeNilKeyword, nilKeyword, unexpectedAfterNilKeyword))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeNilKeyword?.raw, nilKeyword.raw, unexpectedAfterNilKeyword?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.nilLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -5013,6 +4819,7 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeNilKeyword: UnexpectedNodesSyntax? { diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift index 76a1e9e0384..1a9c7f2cdef 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift @@ -49,25 +49,19 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndColon), + Syntax(colon), + Syntax(unexpectedAfterColon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndColon, - colon, - unexpectedAfterColon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name?.raw, - unexpectedBetweenNameAndColon?.raw, - colon?.raw, - unexpectedAfterColon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.objCSelectorPiece, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -75,6 +69,7 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -177,29 +172,21 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeMangledName), + Syntax(mangledName), + Syntax(unexpectedBetweenMangledNameAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndOrdinal), + Syntax(ordinal), + Syntax(unexpectedAfterOrdinal) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeMangledName, - mangledName, - unexpectedBetweenMangledNameAndComma, - comma, - unexpectedBetweenCommaAndOrdinal, - ordinal, - unexpectedAfterOrdinal - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeMangledName?.raw, - mangledName.raw, - unexpectedBetweenMangledNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndOrdinal?.raw, - ordinal.raw, - unexpectedAfterOrdinal?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -207,6 +194,7 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeMangledName: UnexpectedNodesSyntax? { @@ -331,33 +319,23 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeFixitySpecifier), + Syntax(fixitySpecifier), + Syntax(unexpectedBetweenFixitySpecifierAndOperatorKeyword), + Syntax(operatorKeyword), + Syntax(unexpectedBetweenOperatorKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndOperatorPrecedenceAndTypes), + Syntax(operatorPrecedenceAndTypes), + Syntax(unexpectedAfterOperatorPrecedenceAndTypes) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeFixitySpecifier, - fixitySpecifier, - unexpectedBetweenFixitySpecifierAndOperatorKeyword, - operatorKeyword, - unexpectedBetweenOperatorKeywordAndName, - name, - unexpectedBetweenNameAndOperatorPrecedenceAndTypes, - operatorPrecedenceAndTypes, - unexpectedAfterOperatorPrecedenceAndTypes - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeFixitySpecifier?.raw, - fixitySpecifier.raw, - unexpectedBetweenFixitySpecifierAndOperatorKeyword?.raw, - operatorKeyword.raw, - unexpectedBetweenOperatorKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndOperatorPrecedenceAndTypes?.raw, - operatorPrecedenceAndTypes?.raw, - unexpectedAfterOperatorPrecedenceAndTypes?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.operatorDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -365,6 +343,7 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeFixitySpecifier: UnexpectedNodesSyntax? { @@ -519,29 +498,21 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndPrecedenceGroup), + Syntax(precedenceGroup), + Syntax(unexpectedBetweenPrecedenceGroupAndDesignatedTypes), + Syntax(designatedTypes), + Syntax(unexpectedAfterDesignatedTypes) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeColon, - colon, - unexpectedBetweenColonAndPrecedenceGroup, - precedenceGroup, - unexpectedBetweenPrecedenceGroupAndDesignatedTypes, - designatedTypes, - unexpectedAfterDesignatedTypes - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndPrecedenceGroup?.raw, - precedenceGroup.raw, - unexpectedBetweenPrecedenceGroupAndDesignatedTypes?.raw, - designatedTypes.raw, - unexpectedAfterDesignatedTypes?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.operatorPrecedenceAndTypes, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -549,6 +520,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeColon: UnexpectedNodesSyntax? { @@ -629,7 +601,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable, collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -700,33 +672,23 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBindingSpecifier), + Syntax(bindingSpecifier), + Syntax(unexpectedBetweenBindingSpecifierAndPattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndTypeAnnotation), + Syntax(typeAnnotation), + Syntax(unexpectedBetweenTypeAnnotationAndInitializer), + Syntax(initializer), + Syntax(unexpectedAfterInitializer) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBindingSpecifier, - bindingSpecifier, - unexpectedBetweenBindingSpecifierAndPattern, - pattern, - unexpectedBetweenPatternAndTypeAnnotation, - typeAnnotation, - unexpectedBetweenTypeAnnotationAndInitializer, - initializer, - unexpectedAfterInitializer - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBindingSpecifier?.raw, - bindingSpecifier.raw, - unexpectedBetweenBindingSpecifierAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer?.raw, - unexpectedAfterInitializer?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.optionalBindingCondition, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -734,6 +696,7 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBindingSpecifier: UnexpectedNodesSyntax? { @@ -868,25 +831,19 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndQuestionMark), + Syntax(questionMark), + Syntax(unexpectedAfterQuestionMark) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndQuestionMark, - questionMark, - unexpectedAfterQuestionMark - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndQuestionMark?.raw, - questionMark.raw, - unexpectedAfterQuestionMark?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.optionalChainingExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -894,6 +851,7 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -982,25 +940,19 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWrappedType), + Syntax(wrappedType), + Syntax(unexpectedBetweenWrappedTypeAndQuestionMark), + Syntax(questionMark), + Syntax(unexpectedAfterQuestionMark) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWrappedType, - wrappedType, - unexpectedBetweenWrappedTypeAndQuestionMark, - questionMark, - unexpectedAfterQuestionMark - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWrappedType?.raw, - wrappedType.raw, - unexpectedBetweenWrappedTypeAndQuestionMark?.raw, - questionMark.raw, - unexpectedAfterQuestionMark?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.optionalType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1008,6 +960,7 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWrappedType: UnexpectedNodesSyntax? { @@ -1111,37 +1064,25 @@ public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, Synta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeModuleLabel), + Syntax(moduleLabel), + Syntax(unexpectedBetweenModuleLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndModuleName), + Syntax(moduleName), + Syntax(unexpectedBetweenModuleNameAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndPlatforms), + Syntax(platforms), + Syntax(unexpectedAfterPlatforms) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeModuleLabel, - moduleLabel, - unexpectedBetweenModuleLabelAndColon, - colon, - unexpectedBetweenColonAndModuleName, - moduleName, - unexpectedBetweenModuleNameAndComma, - comma, - unexpectedBetweenCommaAndPlatforms, - platforms, - unexpectedAfterPlatforms - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeModuleLabel?.raw, - moduleLabel.raw, - unexpectedBetweenModuleLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndModuleName?.raw, - moduleName.raw, - unexpectedBetweenModuleNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndPlatforms?.raw, - platforms.raw, - unexpectedAfterPlatforms?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.originallyDefinedInAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1149,6 +1090,7 @@ public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, Synta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? { @@ -1265,7 +1207,7 @@ public struct OriginallyDefinedInAttributeArgumentsSyntax: SyntaxProtocol, Synta collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.platformVersionItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1332,25 +1274,19 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeEachKeyword), + Syntax(eachKeyword), + Syntax(unexpectedBetweenEachKeywordAndPack), + Syntax(pack), + Syntax(unexpectedAfterPack) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeEachKeyword, - eachKeyword, - unexpectedBetweenEachKeywordAndPack, - pack, - unexpectedAfterPack - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeEachKeyword?.raw, - eachKeyword.raw, - unexpectedBetweenEachKeywordAndPack?.raw, - pack.raw, - unexpectedAfterPack?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.packElementExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1358,6 +1294,7 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafEx ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? { @@ -1446,25 +1383,19 @@ public struct PackElementTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeEachKeyword), + Syntax(eachKeyword), + Syntax(unexpectedBetweenEachKeywordAndPack), + Syntax(pack), + Syntax(unexpectedAfterPack) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeEachKeyword, - eachKeyword, - unexpectedBetweenEachKeywordAndPack, - pack, - unexpectedAfterPack - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeEachKeyword?.raw, - eachKeyword.raw, - unexpectedBetweenEachKeywordAndPack?.raw, - pack.raw, - unexpectedAfterPack?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.packElementType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1472,6 +1403,7 @@ public struct PackElementTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? { @@ -1562,25 +1494,19 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeRepeatKeyword), + Syntax(repeatKeyword), + Syntax(unexpectedBetweenRepeatKeywordAndRepetitionPattern), + Syntax(repetitionPattern), + Syntax(unexpectedAfterRepetitionPattern) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeRepeatKeyword, - repeatKeyword, - unexpectedBetweenRepeatKeywordAndRepetitionPattern, - repetitionPattern, - unexpectedAfterRepetitionPattern - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeRepeatKeyword?.raw, - repeatKeyword.raw, - unexpectedBetweenRepeatKeywordAndRepetitionPattern?.raw, - repetitionPattern.raw, - unexpectedAfterRepetitionPattern?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.packExpansionExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1588,6 +1514,7 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? { @@ -1676,25 +1603,19 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeRepeatKeyword), + Syntax(repeatKeyword), + Syntax(unexpectedBetweenRepeatKeywordAndRepetitionPattern), + Syntax(repetitionPattern), + Syntax(unexpectedAfterRepetitionPattern) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeRepeatKeyword, - repeatKeyword, - unexpectedBetweenRepeatKeywordAndRepetitionPattern, - repetitionPattern, - unexpectedAfterRepetitionPattern - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeRepeatKeyword?.raw, - repeatKeyword.raw, - unexpectedBetweenRepeatKeywordAndRepetitionPattern?.raw, - repetitionPattern.raw, - unexpectedAfterRepetitionPattern?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.packExpansionType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1702,6 +1623,7 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? { @@ -1809,37 +1731,25 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndTypeAnnotation), + Syntax(typeAnnotation), + Syntax(unexpectedBetweenTypeAnnotationAndInitializer), + Syntax(initializer), + Syntax(unexpectedBetweenInitializerAndAccessorBlock), + Syntax(accessorBlock), + Syntax(unexpectedBetweenAccessorBlockAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePattern, - pattern, - unexpectedBetweenPatternAndTypeAnnotation, - typeAnnotation, - unexpectedBetweenTypeAnnotationAndInitializer, - initializer, - unexpectedBetweenInitializerAndAccessorBlock, - accessorBlock, - unexpectedBetweenAccessorBlockAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTypeAnnotation?.raw, - typeAnnotation?.raw, - unexpectedBetweenTypeAnnotationAndInitializer?.raw, - initializer?.raw, - unexpectedBetweenInitializerAndAccessorBlock?.raw, - accessorBlock?.raw, - unexpectedBetweenAccessorBlockAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.patternBinding, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1847,6 +1757,7 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePattern: UnexpectedNodesSyntax? { @@ -2008,13 +1919,13 @@ public struct PatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforePattern), Syntax(pattern), Syntax(unexpectedAfterPattern)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedAfterPattern))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforePattern?.raw, pattern.raw, unexpectedAfterPattern?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.patternExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2022,6 +1933,7 @@ public struct PatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePattern: UnexpectedNodesSyntax? { @@ -2091,25 +2003,19 @@ public struct PlatformVersionItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePlatformVersion), + Syntax(platformVersion), + Syntax(unexpectedBetweenPlatformVersionAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePlatformVersion, - platformVersion, - unexpectedBetweenPlatformVersionAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePlatformVersion?.raw, - platformVersion.raw, - unexpectedBetweenPlatformVersionAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.platformVersionItem, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2117,6 +2023,7 @@ public struct PlatformVersionItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlatformVersion: UnexpectedNodesSyntax? { @@ -2217,25 +2124,19 @@ public struct PlatformVersionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePlatform), + Syntax(platform), + Syntax(unexpectedBetweenPlatformAndVersion), + Syntax(version), + Syntax(unexpectedAfterVersion) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePlatform, - platform, - unexpectedBetweenPlatformAndVersion, - version, - unexpectedAfterVersion - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePlatform?.raw, - platform.raw, - unexpectedBetweenPlatformAndVersion?.raw, - version?.raw, - unexpectedAfterVersion?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.platformVersion, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2243,6 +2144,7 @@ public struct PlatformVersionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePlatform: UnexpectedNodesSyntax? { @@ -2338,25 +2240,19 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBase), + Syntax(base), + Syntax(unexpectedBetweenBaseAndConfig), + Syntax(config), + Syntax(unexpectedAfterConfig) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBase, - base, - unexpectedBetweenBaseAndConfig, - config, - unexpectedAfterConfig - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBase?.raw, - base?.raw, - unexpectedBetweenBaseAndConfig?.raw, - config.raw, - unexpectedAfterConfig?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.postfixIfConfigExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2364,6 +2260,7 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBase: UnexpectedNodesSyntax? { @@ -2449,25 +2346,19 @@ public struct PostfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndOperator), + Syntax(`operator`), + Syntax(unexpectedAfterOperator) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndOperator, - `operator`, - unexpectedAfterOperator - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndOperator?.raw, - `operator`.raw, - unexpectedAfterOperator?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.postfixOperatorExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2475,6 +2366,7 @@ public struct PostfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -2582,45 +2474,29 @@ public struct PoundSourceLocationArgumentsSyntax: SyntaxProtocol, SyntaxHashable trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeFileLabel), + Syntax(fileLabel), + Syntax(unexpectedBetweenFileLabelAndFileColon), + Syntax(fileColon), + Syntax(unexpectedBetweenFileColonAndFileName), + Syntax(fileName), + Syntax(unexpectedBetweenFileNameAndComma), + Syntax(comma), + Syntax(unexpectedBetweenCommaAndLineLabel), + Syntax(lineLabel), + Syntax(unexpectedBetweenLineLabelAndLineColon), + Syntax(lineColon), + Syntax(unexpectedBetweenLineColonAndLineNumber), + Syntax(lineNumber), + Syntax(unexpectedAfterLineNumber) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeFileLabel, - fileLabel, - unexpectedBetweenFileLabelAndFileColon, - fileColon, - unexpectedBetweenFileColonAndFileName, - fileName, - unexpectedBetweenFileNameAndComma, - comma, - unexpectedBetweenCommaAndLineLabel, - lineLabel, - unexpectedBetweenLineLabelAndLineColon, - lineColon, - unexpectedBetweenLineColonAndLineNumber, - lineNumber, - unexpectedAfterLineNumber - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeFileLabel?.raw, - fileLabel.raw, - unexpectedBetweenFileLabelAndFileColon?.raw, - fileColon.raw, - unexpectedBetweenFileColonAndFileName?.raw, - fileName.raw, - unexpectedBetweenFileNameAndComma?.raw, - comma.raw, - unexpectedBetweenCommaAndLineLabel?.raw, - lineLabel.raw, - unexpectedBetweenLineLabelAndLineColon?.raw, - lineColon.raw, - unexpectedBetweenLineColonAndLineNumber?.raw, - lineNumber.raw, - unexpectedAfterLineNumber?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.poundSourceLocationArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2628,6 +2504,7 @@ public struct PoundSourceLocationArgumentsSyntax: SyntaxProtocol, SyntaxHashable ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeFileLabel: UnexpectedNodesSyntax? { @@ -2837,33 +2714,23 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePoundSourceLocation), + Syntax(poundSourceLocation), + Syntax(unexpectedBetweenPoundSourceLocationAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePoundSourceLocation, - poundSourceLocation, - unexpectedBetweenPoundSourceLocationAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePoundSourceLocation?.raw, - poundSourceLocation.raw, - unexpectedBetweenPoundSourceLocationAndLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndArguments?.raw, - arguments?.raw, - unexpectedBetweenArgumentsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.poundSourceLocation, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2871,6 +2738,7 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePoundSourceLocation: UnexpectedNodesSyntax? { @@ -3015,29 +2883,21 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAssignmentLabel), + Syntax(assignmentLabel), + Syntax(unexpectedBetweenAssignmentLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedAfterValue) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAssignmentLabel, - assignmentLabel, - unexpectedBetweenAssignmentLabelAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedAfterValue - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAssignmentLabel?.raw, - assignmentLabel.raw, - unexpectedBetweenAssignmentLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.precedenceGroupAssignment, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3045,6 +2905,7 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAssignmentLabel: UnexpectedNodesSyntax? { @@ -3173,29 +3034,21 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAssociativityLabel), + Syntax(associativityLabel), + Syntax(unexpectedBetweenAssociativityLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndValue), + Syntax(value), + Syntax(unexpectedAfterValue) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAssociativityLabel, - associativityLabel, - unexpectedBetweenAssociativityLabelAndColon, - colon, - unexpectedBetweenColonAndValue, - value, - unexpectedAfterValue - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAssociativityLabel?.raw, - associativityLabel.raw, - unexpectedBetweenAssociativityLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.precedenceGroupAssociativity, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3203,6 +3056,7 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAssociativityLabel: UnexpectedNodesSyntax? { @@ -3343,45 +3197,29 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndPrecedencegroupKeyword), + Syntax(precedencegroupKeyword), + Syntax(unexpectedBetweenPrecedencegroupKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndLeftBrace), + Syntax(leftBrace), + Syntax(unexpectedBetweenLeftBraceAndGroupAttributes), + Syntax(groupAttributes), + Syntax(unexpectedBetweenGroupAttributesAndRightBrace), + Syntax(rightBrace), + Syntax(unexpectedAfterRightBrace) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndPrecedencegroupKeyword, - precedencegroupKeyword, - unexpectedBetweenPrecedencegroupKeywordAndName, - name, - unexpectedBetweenNameAndLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndGroupAttributes, - groupAttributes, - unexpectedBetweenGroupAttributesAndRightBrace, - rightBrace, - unexpectedAfterRightBrace - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndPrecedencegroupKeyword?.raw, - precedencegroupKeyword.raw, - unexpectedBetweenPrecedencegroupKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndGroupAttributes?.raw, - groupAttributes.raw, - unexpectedBetweenGroupAttributesAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.precedenceGroupDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3389,6 +3227,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -3425,7 +3264,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3471,7 +3310,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3582,7 +3421,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Le collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupAttributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3676,25 +3515,19 @@ public struct PrecedenceGroupNameSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.precedenceGroupName, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3702,6 +3535,7 @@ public struct PrecedenceGroupNameSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -3804,29 +3638,21 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _Le trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeHigherThanOrLowerThanLabel), + Syntax(higherThanOrLowerThanLabel), + Syntax(unexpectedBetweenHigherThanOrLowerThanLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndPrecedenceGroups), + Syntax(precedenceGroups), + Syntax(unexpectedAfterPrecedenceGroups) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeHigherThanOrLowerThanLabel, - higherThanOrLowerThanLabel, - unexpectedBetweenHigherThanOrLowerThanLabelAndColon, - colon, - unexpectedBetweenColonAndPrecedenceGroups, - precedenceGroups, - unexpectedAfterPrecedenceGroups - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeHigherThanOrLowerThanLabel?.raw, - higherThanOrLowerThanLabel.raw, - unexpectedBetweenHigherThanOrLowerThanLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndPrecedenceGroups?.raw, - precedenceGroups.raw, - unexpectedAfterPrecedenceGroups?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.precedenceGroupRelation, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3834,6 +3660,7 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _Le ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeHigherThanOrLowerThanLabel: UnexpectedNodesSyntax? { @@ -3916,7 +3743,7 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable, _Le collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3989,25 +3816,19 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeOperator), + Syntax(`operator`), + Syntax(unexpectedBetweenOperatorAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeOperator, - `operator`, - unexpectedBetweenOperatorAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeOperator?.raw, - `operator`.raw, - unexpectedBetweenOperatorAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.prefixOperatorExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4015,6 +3836,7 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeOperator: UnexpectedNodesSyntax? { @@ -4110,29 +3932,21 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftAngle), + Syntax(leftAngle), + Syntax(unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes), + Syntax(primaryAssociatedTypes), + Syntax(unexpectedBetweenPrimaryAssociatedTypesAndRightAngle), + Syntax(rightAngle), + Syntax(unexpectedAfterRightAngle) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftAngle, - leftAngle, - unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes, - primaryAssociatedTypes, - unexpectedBetweenPrimaryAssociatedTypesAndRightAngle, - rightAngle, - unexpectedAfterRightAngle - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftAngle?.raw, - leftAngle.raw, - unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes?.raw, - primaryAssociatedTypes.raw, - unexpectedBetweenPrimaryAssociatedTypesAndRightAngle?.raw, - rightAngle.raw, - unexpectedAfterRightAngle?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.primaryAssociatedTypeClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4140,6 +3954,7 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftAngle: UnexpectedNodesSyntax? { @@ -4196,7 +4011,7 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.primaryAssociatedTypeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4282,25 +4097,19 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeName), + Syntax(name), + Syntax(unexpectedBetweenNameAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeName, - name, - unexpectedBetweenNameAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeName?.raw, - name.raw, - unexpectedBetweenNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.primaryAssociatedType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4308,6 +4117,7 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeName: UnexpectedNodesSyntax? { @@ -4435,49 +4245,31 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndProtocolKeyword), + Syntax(protocolKeyword), + Syntax(unexpectedBetweenProtocolKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndPrimaryAssociatedTypeClause), + Syntax(primaryAssociatedTypeClause), + Syntax(unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndMemberBlock), + Syntax(memberBlock), + Syntax(unexpectedAfterMemberBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndProtocolKeyword, - protocolKeyword, - unexpectedBetweenProtocolKeywordAndName, - name, - unexpectedBetweenNameAndPrimaryAssociatedTypeClause, - primaryAssociatedTypeClause, - unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndProtocolKeyword?.raw, - protocolKeyword.raw, - unexpectedBetweenProtocolKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndPrimaryAssociatedTypeClause?.raw, - primaryAssociatedTypeClause?.raw, - unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.protocolDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4485,6 +4277,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -4521,7 +4314,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4567,7 +4360,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift index b76e03d360b..89586f5b616 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift @@ -50,37 +50,25 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeOpeningPounds), + Syntax(openingPounds), + Syntax(unexpectedBetweenOpeningPoundsAndOpeningSlash), + Syntax(openingSlash), + Syntax(unexpectedBetweenOpeningSlashAndRegex), + Syntax(regex), + Syntax(unexpectedBetweenRegexAndClosingSlash), + Syntax(closingSlash), + Syntax(unexpectedBetweenClosingSlashAndClosingPounds), + Syntax(closingPounds), + Syntax(unexpectedAfterClosingPounds) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeOpeningPounds, - openingPounds, - unexpectedBetweenOpeningPoundsAndOpeningSlash, - openingSlash, - unexpectedBetweenOpeningSlashAndRegex, - regex, - unexpectedBetweenRegexAndClosingSlash, - closingSlash, - unexpectedBetweenClosingSlashAndClosingPounds, - closingPounds, - unexpectedAfterClosingPounds - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeOpeningPounds?.raw, - openingPounds?.raw, - unexpectedBetweenOpeningPoundsAndOpeningSlash?.raw, - openingSlash.raw, - unexpectedBetweenOpeningSlashAndRegex?.raw, - regex.raw, - unexpectedBetweenRegexAndClosingSlash?.raw, - closingSlash.raw, - unexpectedBetweenClosingSlashAndClosingPounds?.raw, - closingPounds?.raw, - unexpectedAfterClosingPounds?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.regexLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -88,6 +76,7 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeOpeningPounds: UnexpectedNodesSyntax? { @@ -254,33 +243,23 @@ public struct RepeatStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeRepeatKeyword), + Syntax(repeatKeyword), + Syntax(unexpectedBetweenRepeatKeywordAndBody), + Syntax(body), + Syntax(unexpectedBetweenBodyAndWhileKeyword), + Syntax(whileKeyword), + Syntax(unexpectedBetweenWhileKeywordAndCondition), + Syntax(condition), + Syntax(unexpectedAfterCondition) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeRepeatKeyword, - repeatKeyword, - unexpectedBetweenRepeatKeywordAndBody, - body, - unexpectedBetweenBodyAndWhileKeyword, - whileKeyword, - unexpectedBetweenWhileKeywordAndCondition, - condition, - unexpectedAfterCondition - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeRepeatKeyword?.raw, - repeatKeyword.raw, - unexpectedBetweenRepeatKeywordAndBody?.raw, - body.raw, - unexpectedBetweenBodyAndWhileKeyword?.raw, - whileKeyword.raw, - unexpectedBetweenWhileKeywordAndCondition?.raw, - condition.raw, - unexpectedAfterCondition?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.repeatStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -288,6 +267,7 @@ public struct RepeatStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? { @@ -428,25 +408,19 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeArrow), + Syntax(arrow), + Syntax(unexpectedBetweenArrowAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeArrow, - arrow, - unexpectedBetweenArrowAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeArrow?.raw, - arrow.raw, - unexpectedBetweenArrowAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.returnClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -454,6 +428,7 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeArrow: UnexpectedNodesSyntax? { @@ -545,25 +520,19 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeReturnKeyword), + Syntax(returnKeyword), + Syntax(unexpectedBetweenReturnKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeReturnKeyword, - returnKeyword, - unexpectedBetweenReturnKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeReturnKeyword?.raw, - returnKeyword.raw, - unexpectedBetweenReturnKeywordAndExpression?.raw, - expression?.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.returnStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -571,6 +540,7 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? { @@ -666,29 +636,21 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftType), + Syntax(leftType), + Syntax(unexpectedBetweenLeftTypeAndEqual), + Syntax(equal), + Syntax(unexpectedBetweenEqualAndRightType), + Syntax(rightType), + Syntax(unexpectedAfterRightType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftType, - leftType, - unexpectedBetweenLeftTypeAndEqual, - equal, - unexpectedBetweenEqualAndRightType, - rightType, - unexpectedAfterRightType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftType?.raw, - leftType.raw, - unexpectedBetweenLeftTypeAndEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndRightType?.raw, - rightType.raw, - unexpectedAfterRightType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.sameTypeRequirement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -696,6 +658,7 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftType: UnexpectedNodesSyntax? { @@ -812,13 +775,13 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeElements), Syntax(elements), Syntax(unexpectedAfterElements)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeElements, elements, unexpectedAfterElements))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeElements?.raw, elements.raw, unexpectedAfterElements?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.sequenceExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -826,6 +789,7 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeElements: UnexpectedNodesSyntax? { @@ -861,7 +825,7 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.exprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -927,29 +891,21 @@ public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeOpeningQuote), + Syntax(openingQuote), + Syntax(unexpectedBetweenOpeningQuoteAndSegments), + Syntax(segments), + Syntax(unexpectedBetweenSegmentsAndClosingQuote), + Syntax(closingQuote), + Syntax(unexpectedAfterClosingQuote) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeOpeningQuote, - openingQuote, - unexpectedBetweenOpeningQuoteAndSegments, - segments, - unexpectedBetweenSegmentsAndClosingQuote, - closingQuote, - unexpectedAfterClosingQuote - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeOpeningQuote?.raw, - openingQuote.raw, - unexpectedBetweenOpeningQuoteAndSegments?.raw, - segments.raw, - unexpectedBetweenSegmentsAndClosingQuote?.raw, - closingQuote.raw, - unexpectedAfterClosingQuote?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.simpleStringLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -957,6 +913,7 @@ public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeOpeningQuote: UnexpectedNodesSyntax? { @@ -1018,7 +975,7 @@ public struct SimpleStringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.simpleStringLiteralSegmentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1108,13 +1065,13 @@ public struct SimpleTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeSpecifier), Syntax(specifier), Syntax(unexpectedAfterSpecifier)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSpecifier, specifier, unexpectedAfterSpecifier))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeSpecifier?.raw, specifier.raw, unexpectedAfterSpecifier?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.simpleTypeSpecifier, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1122,6 +1079,7 @@ public struct SimpleTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? { @@ -1196,25 +1154,19 @@ public struct SomeOrAnyTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafType trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeSomeOrAnySpecifier), + Syntax(someOrAnySpecifier), + Syntax(unexpectedBetweenSomeOrAnySpecifierAndConstraint), + Syntax(constraint), + Syntax(unexpectedAfterConstraint) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSomeOrAnySpecifier, - someOrAnySpecifier, - unexpectedBetweenSomeOrAnySpecifierAndConstraint, - constraint, - unexpectedAfterConstraint - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSomeOrAnySpecifier?.raw, - someOrAnySpecifier.raw, - unexpectedBetweenSomeOrAnySpecifierAndConstraint?.raw, - constraint.raw, - unexpectedAfterConstraint?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.someOrAnyType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1222,6 +1174,7 @@ public struct SomeOrAnyTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafType ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSomeOrAnySpecifier: UnexpectedNodesSyntax? { @@ -1316,29 +1269,21 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeShebang), + Syntax(shebang), + Syntax(unexpectedBetweenShebangAndStatements), + Syntax(statements), + Syntax(unexpectedBetweenStatementsAndEndOfFileToken), + Syntax(endOfFileToken), + Syntax(unexpectedAfterEndOfFileToken) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeShebang, - shebang, - unexpectedBetweenShebangAndStatements, - statements, - unexpectedBetweenStatementsAndEndOfFileToken, - endOfFileToken, - unexpectedAfterEndOfFileToken - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeShebang?.raw, - shebang?.raw, - unexpectedBetweenShebangAndStatements?.raw, - statements.raw, - unexpectedBetweenStatementsAndEndOfFileToken?.raw, - endOfFileToken.raw, - unexpectedAfterEndOfFileToken?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.sourceFile, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1346,6 +1291,7 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeShebang: UnexpectedNodesSyntax? { @@ -1404,7 +1350,7 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1500,33 +1446,23 @@ public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashab trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAvailabilityLabel), + Syntax(availabilityLabel), + Syntax(unexpectedBetweenAvailabilityLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndAvailabilityArguments), + Syntax(availabilityArguments), + Syntax(unexpectedBetweenAvailabilityArgumentsAndSemicolon), + Syntax(semicolon), + Syntax(unexpectedAfterSemicolon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAvailabilityLabel, - availabilityLabel, - unexpectedBetweenAvailabilityLabelAndColon, - colon, - unexpectedBetweenColonAndAvailabilityArguments, - availabilityArguments, - unexpectedBetweenAvailabilityArgumentsAndSemicolon, - semicolon, - unexpectedAfterSemicolon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAvailabilityLabel?.raw, - availabilityLabel.raw, - unexpectedBetweenAvailabilityLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndAvailabilityArguments?.raw, - availabilityArguments.raw, - unexpectedBetweenAvailabilityArgumentsAndSemicolon?.raw, - semicolon.raw, - unexpectedAfterSemicolon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.specializeAvailabilityArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1534,6 +1470,7 @@ public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashab ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAvailabilityLabel: UnexpectedNodesSyntax? { @@ -1615,7 +1552,7 @@ public struct SpecializeAvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashab collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityArgumentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1715,33 +1652,23 @@ public struct SpecializeTargetFunctionArgumentSyntax: SyntaxProtocol, SyntaxHash trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeTargetLabel), + Syntax(targetLabel), + Syntax(unexpectedBetweenTargetLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndDeclName), + Syntax(declName), + Syntax(unexpectedBetweenDeclNameAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeTargetLabel, - targetLabel, - unexpectedBetweenTargetLabelAndColon, - colon, - unexpectedBetweenColonAndDeclName, - declName, - unexpectedBetweenDeclNameAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeTargetLabel?.raw, - targetLabel.raw, - unexpectedBetweenTargetLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndDeclName?.raw, - declName.raw, - unexpectedBetweenDeclNameAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.specializeTargetFunctionArgument, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1749,6 +1676,7 @@ public struct SpecializeTargetFunctionArgumentSyntax: SyntaxProtocol, SyntaxHash ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeTargetLabel: UnexpectedNodesSyntax? { @@ -1918,37 +1846,25 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeOpeningPounds), + Syntax(openingPounds), + Syntax(unexpectedBetweenOpeningPoundsAndOpeningQuote), + Syntax(openingQuote), + Syntax(unexpectedBetweenOpeningQuoteAndSegments), + Syntax(segments), + Syntax(unexpectedBetweenSegmentsAndClosingQuote), + Syntax(closingQuote), + Syntax(unexpectedBetweenClosingQuoteAndClosingPounds), + Syntax(closingPounds), + Syntax(unexpectedAfterClosingPounds) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeOpeningPounds, - openingPounds, - unexpectedBetweenOpeningPoundsAndOpeningQuote, - openingQuote, - unexpectedBetweenOpeningQuoteAndSegments, - segments, - unexpectedBetweenSegmentsAndClosingQuote, - closingQuote, - unexpectedBetweenClosingQuoteAndClosingPounds, - closingPounds, - unexpectedAfterClosingPounds - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeOpeningPounds?.raw, - openingPounds?.raw, - unexpectedBetweenOpeningPoundsAndOpeningQuote?.raw, - openingQuote.raw, - unexpectedBetweenOpeningQuoteAndSegments?.raw, - segments.raw, - unexpectedBetweenSegmentsAndClosingQuote?.raw, - closingQuote.raw, - unexpectedBetweenClosingQuoteAndClosingPounds?.raw, - closingPounds?.raw, - unexpectedAfterClosingPounds?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.stringLiteralExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1956,6 +1872,7 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeOpeningPounds: UnexpectedNodesSyntax? { @@ -2036,7 +1953,7 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralSegmentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2152,13 +2069,13 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeContent), Syntax(content), Syntax(unexpectedAfterContent)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeContent, content, unexpectedAfterContent))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeContent?.raw, content.raw, unexpectedAfterContent?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.stringSegment, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2166,6 +2083,7 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeContent: UnexpectedNodesSyntax? { @@ -2314,49 +2232,31 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndStructKeyword), + Syntax(structKeyword), + Syntax(unexpectedBetweenStructKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndInheritanceClause), + Syntax(inheritanceClause), + Syntax(unexpectedBetweenInheritanceClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndMemberBlock), + Syntax(memberBlock), + Syntax(unexpectedAfterMemberBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndStructKeyword, - structKeyword, - unexpectedBetweenStructKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInheritanceClause, - inheritanceClause, - unexpectedBetweenInheritanceClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndMemberBlock, - memberBlock, - unexpectedAfterMemberBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndStructKeyword?.raw, - structKeyword.raw, - unexpectedBetweenStructKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndInheritanceClause?.raw, - inheritanceClause?.raw, - unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw, - memberBlock.raw, - unexpectedAfterMemberBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.structDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2364,6 +2264,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -2400,7 +2301,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2446,7 +2347,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2651,41 +2552,27 @@ public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCalledExpression), + Syntax(calledExpression), + Syntax(unexpectedBetweenCalledExpressionAndLeftSquare), + Syntax(leftSquare), + Syntax(unexpectedBetweenLeftSquareAndArguments), + Syntax(arguments), + Syntax(unexpectedBetweenArgumentsAndRightSquare), + Syntax(rightSquare), + Syntax(unexpectedBetweenRightSquareAndTrailingClosure), + Syntax(trailingClosure), + Syntax(unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures), + Syntax(additionalTrailingClosures), + Syntax(unexpectedAfterAdditionalTrailingClosures) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCalledExpression, - calledExpression, - unexpectedBetweenCalledExpressionAndLeftSquare, - leftSquare, - unexpectedBetweenLeftSquareAndArguments, - arguments, - unexpectedBetweenArgumentsAndRightSquare, - rightSquare, - unexpectedBetweenRightSquareAndTrailingClosure, - trailingClosure, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, - additionalTrailingClosures, - unexpectedAfterAdditionalTrailingClosures - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCalledExpression?.raw, - calledExpression.raw, - unexpectedBetweenCalledExpressionAndLeftSquare?.raw, - leftSquare.raw, - unexpectedBetweenLeftSquareAndArguments?.raw, - arguments.raw, - unexpectedBetweenArgumentsAndRightSquare?.raw, - rightSquare.raw, - unexpectedBetweenRightSquareAndTrailingClosure?.raw, - trailingClosure?.raw, - unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures?.raw, - additionalTrailingClosures.raw, - unexpectedAfterAdditionalTrailingClosures?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.subscriptCallExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2693,6 +2580,7 @@ public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? { @@ -2767,7 +2655,7 @@ public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2851,7 +2739,7 @@ public struct SubscriptCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2938,49 +2826,31 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndSubscriptKeyword), + Syntax(subscriptKeyword), + Syntax(unexpectedBetweenSubscriptKeywordAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndParameterClause), + Syntax(parameterClause), + Syntax(unexpectedBetweenParameterClauseAndReturnClause), + Syntax(returnClause), + Syntax(unexpectedBetweenReturnClauseAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedBetweenGenericWhereClauseAndAccessorBlock), + Syntax(accessorBlock), + Syntax(unexpectedAfterAccessorBlock) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndSubscriptKeyword, - subscriptKeyword, - unexpectedBetweenSubscriptKeywordAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndParameterClause, - parameterClause, - unexpectedBetweenParameterClauseAndReturnClause, - returnClause, - unexpectedBetweenReturnClauseAndGenericWhereClause, - genericWhereClause, - unexpectedBetweenGenericWhereClauseAndAccessorBlock, - accessorBlock, - unexpectedAfterAccessorBlock - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndSubscriptKeyword?.raw, - subscriptKeyword.raw, - unexpectedBetweenSubscriptKeywordAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndParameterClause?.raw, - parameterClause.raw, - unexpectedBetweenParameterClauseAndReturnClause?.raw, - returnClause.raw, - unexpectedBetweenReturnClauseAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedBetweenGenericWhereClauseAndAccessorBlock?.raw, - accessorBlock?.raw, - unexpectedAfterAccessorBlock?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.subscriptDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2988,6 +2858,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -3023,7 +2894,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3068,7 +2939,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3249,13 +3120,13 @@ public struct SuperExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeSuperKeyword), Syntax(superKeyword), Syntax(unexpectedAfterSuperKeyword)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSuperKeyword, superKeyword, unexpectedAfterSuperKeyword))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeSuperKeyword?.raw, superKeyword.raw, unexpectedAfterSuperKeyword?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.superExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3263,6 +3134,7 @@ public struct SuperExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSuperKeyword: UnexpectedNodesSyntax? { @@ -3327,25 +3199,19 @@ public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWithoutTilde), + Syntax(withoutTilde), + Syntax(unexpectedBetweenWithoutTildeAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWithoutTilde, - withoutTilde, - unexpectedBetweenWithoutTildeAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWithoutTilde?.raw, - withoutTilde.raw, - unexpectedBetweenWithoutTildeAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.suppressedType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3353,6 +3219,7 @@ public struct SuppressedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTyp ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWithoutTilde: UnexpectedNodesSyntax? { @@ -3448,29 +3315,21 @@ public struct SwitchCaseItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndWhereClause), + Syntax(whereClause), + Syntax(unexpectedBetweenWhereClauseAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePattern, - pattern, - unexpectedBetweenPatternAndWhereClause, - whereClause, - unexpectedBetweenWhereClauseAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndWhereClause?.raw, - whereClause?.raw, - unexpectedBetweenWhereClauseAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.switchCaseItem, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3478,6 +3337,7 @@ public struct SwitchCaseItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePattern: UnexpectedNodesSyntax? { @@ -3593,29 +3453,21 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCaseKeyword), + Syntax(caseKeyword), + Syntax(unexpectedBetweenCaseKeywordAndCaseItems), + Syntax(caseItems), + Syntax(unexpectedBetweenCaseItemsAndColon), + Syntax(colon), + Syntax(unexpectedAfterColon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCaseKeyword, - caseKeyword, - unexpectedBetweenCaseKeywordAndCaseItems, - caseItems, - unexpectedBetweenCaseItemsAndColon, - colon, - unexpectedAfterColon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCaseKeyword?.raw, - caseKeyword.raw, - unexpectedBetweenCaseKeywordAndCaseItems?.raw, - caseItems.raw, - unexpectedBetweenCaseItemsAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.switchCaseLabel, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3623,6 +3475,7 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? { @@ -3679,7 +3532,7 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3851,29 +3704,21 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttribute), + Syntax(attribute), + Syntax(unexpectedBetweenAttributeAndLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndStatements), + Syntax(statements), + Syntax(unexpectedAfterStatements) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttribute, - attribute, - unexpectedBetweenAttributeAndLabel, - label, - unexpectedBetweenLabelAndStatements, - statements, - unexpectedAfterStatements - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttribute?.raw, - attribute?.raw, - unexpectedBetweenAttributeAndLabel?.raw, - label.raw, - unexpectedBetweenLabelAndStatements?.raw, - statements.raw, - unexpectedAfterStatements?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.switchCase, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3881,6 +3726,7 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttribute: UnexpectedNodesSyntax? { @@ -3953,7 +3799,7 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeP collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4018,25 +3864,19 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeDefaultKeyword), + Syntax(defaultKeyword), + Syntax(unexpectedBetweenDefaultKeywordAndColon), + Syntax(colon), + Syntax(unexpectedAfterColon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeDefaultKeyword, - defaultKeyword, - unexpectedBetweenDefaultKeywordAndColon, - colon, - unexpectedAfterColon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeDefaultKeyword?.raw, - defaultKeyword.raw, - unexpectedBetweenDefaultKeywordAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.switchDefaultLabel, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4044,6 +3884,7 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? { @@ -4162,37 +4003,25 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeSwitchKeyword), + Syntax(switchKeyword), + Syntax(unexpectedBetweenSwitchKeywordAndSubject), + Syntax(subject), + Syntax(unexpectedBetweenSubjectAndLeftBrace), + Syntax(leftBrace), + Syntax(unexpectedBetweenLeftBraceAndCases), + Syntax(cases), + Syntax(unexpectedBetweenCasesAndRightBrace), + Syntax(rightBrace), + Syntax(unexpectedAfterRightBrace) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSwitchKeyword, - switchKeyword, - unexpectedBetweenSwitchKeywordAndSubject, - subject, - unexpectedBetweenSubjectAndLeftBrace, - leftBrace, - unexpectedBetweenLeftBraceAndCases, - cases, - unexpectedBetweenCasesAndRightBrace, - rightBrace, - unexpectedAfterRightBrace - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSwitchKeyword?.raw, - switchKeyword.raw, - unexpectedBetweenSwitchKeywordAndSubject?.raw, - subject.raw, - unexpectedBetweenSubjectAndLeftBrace?.raw, - leftBrace.raw, - unexpectedBetweenLeftBraceAndCases?.raw, - cases.raw, - unexpectedBetweenCasesAndRightBrace?.raw, - rightBrace.raw, - unexpectedAfterRightBrace?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.switchExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4200,6 +4029,7 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? { @@ -4301,7 +4131,7 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift index 61a0750101c..fc917ca7515 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift @@ -61,37 +61,25 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeCondition), + Syntax(condition), + Syntax(unexpectedBetweenConditionAndQuestionMark), + Syntax(questionMark), + Syntax(unexpectedBetweenQuestionMarkAndThenExpression), + Syntax(thenExpression), + Syntax(unexpectedBetweenThenExpressionAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndElseExpression), + Syntax(elseExpression), + Syntax(unexpectedAfterElseExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeCondition, - condition, - unexpectedBetweenConditionAndQuestionMark, - questionMark, - unexpectedBetweenQuestionMarkAndThenExpression, - thenExpression, - unexpectedBetweenThenExpressionAndColon, - colon, - unexpectedBetweenColonAndElseExpression, - elseExpression, - unexpectedAfterElseExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeCondition?.raw, - condition.raw, - unexpectedBetweenConditionAndQuestionMark?.raw, - questionMark.raw, - unexpectedBetweenQuestionMarkAndThenExpression?.raw, - thenExpression.raw, - unexpectedBetweenThenExpressionAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndElseExpression?.raw, - elseExpression.raw, - unexpectedAfterElseExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.ternaryExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -99,6 +87,7 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeCondition: UnexpectedNodesSyntax? { @@ -263,25 +252,19 @@ public struct ThenStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeThenKeyword), + Syntax(thenKeyword), + Syntax(unexpectedBetweenThenKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeThenKeyword, - thenKeyword, - unexpectedBetweenThenKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeThenKeyword?.raw, - thenKeyword.raw, - unexpectedBetweenThenKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.thenStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -289,6 +272,7 @@ public struct ThenStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeThenKeyword: UnexpectedNodesSyntax? { @@ -377,25 +361,19 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeThrowKeyword), + Syntax(throwKeyword), + Syntax(unexpectedBetweenThrowKeywordAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeThrowKeyword, - throwKeyword, - unexpectedBetweenThrowKeywordAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeThrowKeyword?.raw, - throwKeyword.raw, - unexpectedBetweenThrowKeywordAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.throwStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -403,6 +381,7 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? { @@ -508,33 +487,23 @@ public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeThrowsSpecifier), + Syntax(throwsSpecifier), + Syntax(unexpectedBetweenThrowsSpecifierAndLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeThrowsSpecifier, - throwsSpecifier, - unexpectedBetweenThrowsSpecifierAndLeftParen, - leftParen, - unexpectedBetweenLeftParenAndType, - type, - unexpectedBetweenTypeAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeThrowsSpecifier?.raw, - throwsSpecifier.raw, - unexpectedBetweenThrowsSpecifierAndLeftParen?.raw, - leftParen?.raw, - unexpectedBetweenLeftParenAndType?.raw, - type?.raw, - unexpectedBetweenTypeAndRightParen?.raw, - rightParen?.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.throwsClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -542,6 +511,7 @@ public struct ThrowsClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeThrowsSpecifier: UnexpectedNodesSyntax? { @@ -704,29 +674,21 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntax trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeTryKeyword), + Syntax(tryKeyword), + Syntax(unexpectedBetweenTryKeywordAndQuestionOrExclamationMark), + Syntax(questionOrExclamationMark), + Syntax(unexpectedBetweenQuestionOrExclamationMarkAndExpression), + Syntax(expression), + Syntax(unexpectedAfterExpression) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeTryKeyword, - tryKeyword, - unexpectedBetweenTryKeywordAndQuestionOrExclamationMark, - questionOrExclamationMark, - unexpectedBetweenQuestionOrExclamationMarkAndExpression, - expression, - unexpectedAfterExpression - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeTryKeyword?.raw, - tryKeyword.raw, - unexpectedBetweenTryKeywordAndQuestionOrExclamationMark?.raw, - questionOrExclamationMark?.raw, - unexpectedBetweenQuestionOrExclamationMarkAndExpression?.raw, - expression.raw, - unexpectedAfterExpression?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.tryExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -734,6 +696,7 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntax ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeTryKeyword: UnexpectedNodesSyntax? { @@ -850,29 +813,21 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndElements), + Syntax(elements), + Syntax(unexpectedBetweenElementsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndElements, - elements, - unexpectedBetweenElementsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElements?.raw, - elements.raw, - unexpectedBetweenElementsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.tupleExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -880,6 +835,7 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -936,7 +892,7 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.labeledExprList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1034,33 +990,23 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLabel), + Syntax(label), + Syntax(unexpectedBetweenLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndPattern), + Syntax(pattern), + Syntax(unexpectedBetweenPatternAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLabel, - label, - unexpectedBetweenLabelAndColon, - colon, - unexpectedBetweenColonAndPattern, - pattern, - unexpectedBetweenPatternAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLabel?.raw, - label?.raw, - unexpectedBetweenLabelAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndPattern?.raw, - pattern.raw, - unexpectedBetweenPatternAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.tuplePatternElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1068,6 +1014,7 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSy ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLabel: UnexpectedNodesSyntax? { @@ -1225,29 +1172,21 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPa trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndElements), + Syntax(elements), + Syntax(unexpectedBetweenElementsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndElements, - elements, - unexpectedBetweenElementsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElements?.raw, - elements.raw, - unexpectedBetweenElementsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.tuplePattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1255,6 +1194,7 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPa ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -1313,7 +1253,7 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _LeafPa collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.tuplePatternElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1416,45 +1356,29 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeInoutKeyword), + Syntax(inoutKeyword), + Syntax(unexpectedBetweenInoutKeywordAndFirstName), + Syntax(firstName), + Syntax(unexpectedBetweenFirstNameAndSecondName), + Syntax(secondName), + Syntax(unexpectedBetweenSecondNameAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndType), + Syntax(type), + Syntax(unexpectedBetweenTypeAndEllipsis), + Syntax(ellipsis), + Syntax(unexpectedBetweenEllipsisAndTrailingComma), + Syntax(trailingComma), + Syntax(unexpectedAfterTrailingComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeInoutKeyword, - inoutKeyword, - unexpectedBetweenInoutKeywordAndFirstName, - firstName, - unexpectedBetweenFirstNameAndSecondName, - secondName, - unexpectedBetweenSecondNameAndColon, - colon, - unexpectedBetweenColonAndType, - type, - unexpectedBetweenTypeAndEllipsis, - ellipsis, - unexpectedBetweenEllipsisAndTrailingComma, - trailingComma, - unexpectedAfterTrailingComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeInoutKeyword?.raw, - inoutKeyword?.raw, - unexpectedBetweenInoutKeywordAndFirstName?.raw, - firstName?.raw, - unexpectedBetweenFirstNameAndSecondName?.raw, - secondName?.raw, - unexpectedBetweenSecondNameAndColon?.raw, - colon?.raw, - unexpectedBetweenColonAndType?.raw, - type.raw, - unexpectedBetweenTypeAndEllipsis?.raw, - ellipsis?.raw, - unexpectedBetweenEllipsisAndTrailingComma?.raw, - trailingComma?.raw, - unexpectedAfterTrailingComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.tupleTypeElement, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1462,6 +1386,7 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeInoutKeyword: UnexpectedNodesSyntax? { @@ -1672,29 +1597,21 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndElements), + Syntax(elements), + Syntax(unexpectedBetweenElementsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndElements, - elements, - unexpectedBetweenElementsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElements?.raw, - elements.raw, - unexpectedBetweenElementsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.tupleType, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1702,6 +1619,7 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -1758,7 +1676,7 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1857,45 +1775,29 @@ public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndTypealiasKeyword), + Syntax(typealiasKeyword), + Syntax(unexpectedBetweenTypealiasKeywordAndName), + Syntax(name), + Syntax(unexpectedBetweenNameAndGenericParameterClause), + Syntax(genericParameterClause), + Syntax(unexpectedBetweenGenericParameterClauseAndInitializer), + Syntax(initializer), + Syntax(unexpectedBetweenInitializerAndGenericWhereClause), + Syntax(genericWhereClause), + Syntax(unexpectedAfterGenericWhereClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndTypealiasKeyword, - typealiasKeyword, - unexpectedBetweenTypealiasKeywordAndName, - name, - unexpectedBetweenNameAndGenericParameterClause, - genericParameterClause, - unexpectedBetweenGenericParameterClauseAndInitializer, - initializer, - unexpectedBetweenInitializerAndGenericWhereClause, - genericWhereClause, - unexpectedAfterGenericWhereClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndTypealiasKeyword?.raw, - typealiasKeyword.raw, - unexpectedBetweenTypealiasKeywordAndName?.raw, - name.raw, - unexpectedBetweenNameAndGenericParameterClause?.raw, - genericParameterClause?.raw, - unexpectedBetweenGenericParameterClauseAndInitializer?.raw, - initializer.raw, - unexpectedBetweenInitializerAndGenericWhereClause?.raw, - genericWhereClause?.raw, - unexpectedAfterGenericWhereClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeAliasDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -1903,6 +1805,7 @@ public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -1938,7 +1841,7 @@ public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -1983,7 +1886,7 @@ public struct TypeAliasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -2158,25 +2061,19 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndType), + Syntax(type), + Syntax(unexpectedAfterType) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeColon, - colon, - unexpectedBetweenColonAndType, - type, - unexpectedAfterType - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeColon?.raw, - colon.raw, - unexpectedBetweenColonAndType?.raw, - type.raw, - unexpectedAfterType?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeAnnotation, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2184,6 +2081,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxN ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeColon: UnexpectedNodesSyntax? { @@ -2281,25 +2179,19 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAsyncSpecifier), + Syntax(asyncSpecifier), + Syntax(unexpectedBetweenAsyncSpecifierAndThrowsClause), + Syntax(throwsClause), + Syntax(unexpectedAfterThrowsClause) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAsyncSpecifier, - asyncSpecifier, - unexpectedBetweenAsyncSpecifierAndThrowsClause, - throwsClause, - unexpectedAfterThrowsClause - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAsyncSpecifier?.raw, - asyncSpecifier?.raw, - unexpectedBetweenAsyncSpecifierAndThrowsClause?.raw, - throwsClause?.raw, - unexpectedAfterThrowsClause?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeEffectSpecifiers, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2307,6 +2199,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable, _LeafS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { @@ -2393,13 +2286,13 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeType), Syntax(type), Syntax(unexpectedAfterType)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeType, type, unexpectedAfterType))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeType?.raw, type.raw, unexpectedAfterType?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2407,6 +2300,7 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeType: UnexpectedNodesSyntax? { @@ -2473,25 +2367,19 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeEqual), + Syntax(equal), + Syntax(unexpectedBetweenEqualAndValue), + Syntax(value), + Syntax(unexpectedAfterValue) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeEqual, - equal, - unexpectedBetweenEqualAndValue, - value, - unexpectedAfterValue - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeEqual?.raw, - equal.raw, - unexpectedBetweenEqualAndValue?.raw, - value.raw, - unexpectedAfterValue?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.typeInitializerClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2499,6 +2387,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable, _Leaf ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeEqual: UnexpectedNodesSyntax? { @@ -2596,29 +2485,21 @@ public struct UnavailableFromAsyncAttributeArgumentsSyntax: SyntaxProtocol, Synt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeMessageLabel), + Syntax(messageLabel), + Syntax(unexpectedBetweenMessageLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndMessage), + Syntax(message), + Syntax(unexpectedAfterMessage) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeMessageLabel, - messageLabel, - unexpectedBetweenMessageLabelAndColon, - colon, - unexpectedBetweenColonAndMessage, - message, - unexpectedAfterMessage - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeMessageLabel?.raw, - messageLabel.raw, - unexpectedBetweenMessageLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndMessage?.raw, - message.raw, - unexpectedAfterMessage?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.unavailableFromAsyncAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2626,6 +2507,7 @@ public struct UnavailableFromAsyncAttributeArgumentsSyntax: SyntaxProtocol, Synt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? { @@ -2746,29 +2628,21 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeSourceFileLabel), + Syntax(sourceFileLabel), + Syntax(unexpectedBetweenSourceFileLabelAndColon), + Syntax(colon), + Syntax(unexpectedBetweenColonAndFilename), + Syntax(filename), + Syntax(unexpectedAfterFilename) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeSourceFileLabel, - sourceFileLabel, - unexpectedBetweenSourceFileLabelAndColon, - colon, - unexpectedBetweenColonAndFilename, - filename, - unexpectedAfterFilename - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeSourceFileLabel?.raw, - sourceFileLabel.raw, - unexpectedBetweenSourceFileLabelAndColon?.raw, - colon.raw, - unexpectedBetweenColonAndFilename?.raw, - filename.raw, - unexpectedAfterFilename?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.underscorePrivateAttributeArguments, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2776,6 +2650,7 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? { @@ -2892,25 +2767,19 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAsKeyword), + Syntax(asKeyword), + Syntax(unexpectedBetweenAsKeywordAndQuestionOrExclamationMark), + Syntax(questionOrExclamationMark), + Syntax(unexpectedAfterQuestionOrExclamationMark) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAsKeyword, - asKeyword, - unexpectedBetweenAsKeywordAndQuestionOrExclamationMark, - questionOrExclamationMark, - unexpectedAfterQuestionOrExclamationMark - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAsKeyword?.raw, - asKeyword.raw, - unexpectedBetweenAsKeywordAndQuestionOrExclamationMark?.raw, - questionOrExclamationMark?.raw, - unexpectedAfterQuestionOrExclamationMark?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.unresolvedAsExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -2918,6 +2787,7 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAsKeyword: UnexpectedNodesSyntax? { @@ -3013,13 +2883,13 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeIsKeyword), Syntax(isKeyword), Syntax(unexpectedAfterIsKeyword)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIsKeyword, isKeyword, unexpectedAfterIsKeyword))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeIsKeyword?.raw, isKeyword.raw, unexpectedAfterIsKeyword?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.unresolvedIsExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3027,6 +2897,7 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafE ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeIsKeyword: UnexpectedNodesSyntax? { @@ -3100,29 +2971,21 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeQuestionMark), + Syntax(questionMark), + Syntax(unexpectedBetweenQuestionMarkAndThenExpression), + Syntax(thenExpression), + Syntax(unexpectedBetweenThenExpressionAndColon), + Syntax(colon), + Syntax(unexpectedAfterColon) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeQuestionMark, - questionMark, - unexpectedBetweenQuestionMarkAndThenExpression, - thenExpression, - unexpectedBetweenThenExpressionAndColon, - colon, - unexpectedAfterColon - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeQuestionMark?.raw, - questionMark.raw, - unexpectedBetweenQuestionMarkAndThenExpression?.raw, - thenExpression.raw, - unexpectedBetweenThenExpressionAndColon?.raw, - colon.raw, - unexpectedAfterColon?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.unresolvedTernaryExpr, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3130,6 +2993,7 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _ ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? { @@ -3241,25 +3105,19 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeBindingSpecifier), + Syntax(bindingSpecifier), + Syntax(unexpectedBetweenBindingSpecifierAndPattern), + Syntax(pattern), + Syntax(unexpectedAfterPattern) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeBindingSpecifier, - bindingSpecifier, - unexpectedBetweenBindingSpecifierAndPattern, - pattern, - unexpectedAfterPattern - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeBindingSpecifier?.raw, - bindingSpecifier.raw, - unexpectedBetweenBindingSpecifierAndPattern?.raw, - pattern.raw, - unexpectedAfterPattern?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.valueBindingPattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3267,6 +3125,7 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeBindingSpecifier: UnexpectedNodesSyntax? { @@ -3376,33 +3235,23 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeAttributes), + Syntax(attributes), + Syntax(unexpectedBetweenAttributesAndModifiers), + Syntax(modifiers), + Syntax(unexpectedBetweenModifiersAndBindingSpecifier), + Syntax(bindingSpecifier), + Syntax(unexpectedBetweenBindingSpecifierAndBindings), + Syntax(bindings), + Syntax(unexpectedAfterBindings) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeAttributes, - attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers, - unexpectedBetweenModifiersAndBindingSpecifier, - bindingSpecifier, - unexpectedBetweenBindingSpecifierAndBindings, - bindings, - unexpectedAfterBindings - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeAttributes?.raw, - attributes.raw, - unexpectedBetweenAttributesAndModifiers?.raw, - modifiers.raw, - unexpectedBetweenModifiersAndBindingSpecifier?.raw, - bindingSpecifier.raw, - unexpectedBetweenBindingSpecifierAndBindings?.raw, - bindings.raw, - unexpectedAfterBindings?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.variableDecl, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3410,6 +3259,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? { @@ -3445,7 +3295,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3491,7 +3341,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3576,7 +3426,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.patternBindingList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3647,25 +3497,19 @@ public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforePeriod), + Syntax(period), + Syntax(unexpectedBetweenPeriodAndNumber), + Syntax(number), + Syntax(unexpectedAfterNumber) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforePeriod, - period, - unexpectedBetweenPeriodAndNumber, - number, - unexpectedAfterNumber - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforePeriod?.raw, - period.raw, - unexpectedBetweenPeriodAndNumber?.raw, - number.raw, - unexpectedAfterNumber?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.versionComponent, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3673,6 +3517,7 @@ public struct VersionComponentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynta ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforePeriod: UnexpectedNodesSyntax? { @@ -3778,25 +3623,19 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeMajor), + Syntax(major), + Syntax(unexpectedBetweenMajorAndComponents), + Syntax(components), + Syntax(unexpectedAfterComponents) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeMajor, - major, - unexpectedBetweenMajorAndComponents, - components, - unexpectedAfterComponents - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeMajor?.raw, - major.raw, - unexpectedBetweenMajorAndComponents?.raw, - components.raw, - unexpectedAfterComponents?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.versionTuple, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3804,6 +3643,7 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeMajor: UnexpectedNodesSyntax? { @@ -3863,7 +3703,7 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNod collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.versionComponentList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -3928,25 +3768,19 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWhereKeyword), + Syntax(whereKeyword), + Syntax(unexpectedBetweenWhereKeywordAndCondition), + Syntax(condition), + Syntax(unexpectedAfterCondition) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWhereKeyword, - whereKeyword, - unexpectedBetweenWhereKeywordAndCondition, - condition, - unexpectedAfterCondition - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWhereKeyword?.raw, - whereKeyword.raw, - unexpectedBetweenWhereKeywordAndCondition?.raw, - condition.raw, - unexpectedAfterCondition?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.whereClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -3954,6 +3788,7 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNode ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? { @@ -4045,29 +3880,21 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeWhileKeyword), + Syntax(whileKeyword), + Syntax(unexpectedBetweenWhileKeywordAndConditions), + Syntax(conditions), + Syntax(unexpectedBetweenConditionsAndBody), + Syntax(body), + Syntax(unexpectedAfterBody) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeWhileKeyword, - whileKeyword, - unexpectedBetweenWhileKeywordAndConditions, - conditions, - unexpectedBetweenConditionsAndBody, - body, - unexpectedAfterBody - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeWhileKeyword?.raw, - whileKeyword.raw, - unexpectedBetweenWhileKeywordAndConditions?.raw, - conditions.raw, - unexpectedBetweenConditionsAndBody?.raw, - body.raw, - unexpectedAfterBody?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.whileStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4075,6 +3902,7 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWhileKeyword: UnexpectedNodesSyntax? { @@ -4131,7 +3959,7 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( @@ -4220,13 +4048,13 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Lea trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [Syntax(unexpectedBeforeWildcard), Syntax(wildcard), Syntax(unexpectedAfterWildcard)] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWildcard, wildcard, unexpectedAfterWildcard))) { (arena, _) in - let layout: [RawSyntax?] = [unexpectedBeforeWildcard?.raw, wildcard.raw, unexpectedAfterWildcard?.raw] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.wildcardPattern, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4234,6 +4062,7 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable, _Lea ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeWildcard: UnexpectedNodesSyntax? { @@ -4380,25 +4209,19 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeYieldKeyword), + Syntax(yieldKeyword), + Syntax(unexpectedBetweenYieldKeywordAndYieldedExpressions), + Syntax(yieldedExpressions), + Syntax(unexpectedAfterYieldedExpressions) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeYieldKeyword, - yieldKeyword, - unexpectedBetweenYieldKeywordAndYieldedExpressions, - yieldedExpressions, - unexpectedAfterYieldedExpressions - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeYieldKeyword?.raw, - yieldKeyword.raw, - unexpectedBetweenYieldKeywordAndYieldedExpressions?.raw, - yieldedExpressions.raw, - unexpectedAfterYieldedExpressions?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.yieldStmt, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4406,6 +4229,7 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? { @@ -4498,25 +4322,19 @@ public struct YieldedExpressionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeExpression), + Syntax(expression), + Syntax(unexpectedBetweenExpressionAndComma), + Syntax(comma), + Syntax(unexpectedAfterComma) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeExpression, - expression, - unexpectedBetweenExpressionAndComma, - comma, - unexpectedAfterComma - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeExpression?.raw, - expression.raw, - unexpectedBetweenExpressionAndComma?.raw, - comma?.raw, - unexpectedAfterComma?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.yieldedExpression, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4524,6 +4342,7 @@ public struct YieldedExpressionSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeExpression: UnexpectedNodesSyntax? { @@ -4619,29 +4438,21 @@ public struct YieldedExpressionsClauseSyntax: SyntaxProtocol, SyntaxHashable, _L trailingTrivia: Trivia? = nil ) { + let nodes: [Syntax?] = [ + Syntax(unexpectedBeforeLeftParen), + Syntax(leftParen), + Syntax(unexpectedBetweenLeftParenAndElements), + Syntax(elements), + Syntax(unexpectedBetweenElementsAndRightParen), + Syntax(rightParen), + Syntax(unexpectedAfterRightParen) + ] // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - self = withExtendedLifetime((SyntaxArena(), ( - unexpectedBeforeLeftParen, - leftParen, - unexpectedBetweenLeftParenAndElements, - elements, - unexpectedBetweenElementsAndRightParen, - rightParen, - unexpectedAfterRightParen - ))) { (arena, _) in - let layout: [RawSyntax?] = [ - unexpectedBeforeLeftParen?.raw, - leftParen.raw, - unexpectedBetweenLeftParenAndElements?.raw, - elements.raw, - unexpectedBetweenElementsAndRightParen?.raw, - rightParen.raw, - unexpectedAfterRightParen?.raw - ] + self = withExtendedLifetime(SyntaxArena()) { (arena) in let raw = RawSyntax.makeLayout( kind: SyntaxKind.yieldedExpressionsClause, - from: layout, + from: nodes, arena: arena, leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia @@ -4649,6 +4460,7 @@ public struct YieldedExpressionsClauseSyntax: SyntaxProtocol, SyntaxHashable, _L ) return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self) } + Syntax(self).setSyntaxTrackingOfTree(SyntaxTracking(tracking: nodes)) } public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? { @@ -4705,7 +4517,7 @@ public struct YieldedExpressionsClauseSyntax: SyntaxProtocol, SyntaxHashable, _L collection = col.layoutView!.appending(element.raw, arena: arena) } else { collection = RawSyntax.makeLayout(kind: SyntaxKind.yieldedExpressionList, - from: [element.raw], arena: arena) + from: [Syntax(element)], arena: arena) } return Syntax(self) .replacingChild( diff --git a/Tests/SwiftSyntaxTest/MemoryLayoutTest.swift b/Tests/SwiftSyntaxTest/MemoryLayoutTest.swift index af45e08f7fb..c4f18e7edfc 100644 --- a/Tests/SwiftSyntaxTest/MemoryLayoutTest.swift +++ b/Tests/SwiftSyntaxTest/MemoryLayoutTest.swift @@ -34,8 +34,8 @@ final class MemoryLayoutTest: XCTestCase { "Syntax": .init(size: 16, stride: 16, alignment: 8), "Syntax.Info": .init(size: 8, stride: 8, alignment: 8), - "Syntax.Info.Root": .init(size: 8, stride: 8, alignment: 8), - "Syntax.Info.NonRoot": .init(size: 36, stride: 40, alignment: 8), + "Syntax.Info.Root": .init(size: 24, stride: 24, alignment: 8), + "Syntax.Info.NonRoot": .init(size: 48, stride: 48, alignment: 8), ] let values = SyntaxMemoryLayout.values diff --git a/Tests/SwiftSyntaxTest/SyntaxTrackingTests.swift b/Tests/SwiftSyntaxTest/SyntaxTrackingTests.swift new file mode 100644 index 00000000000..135edaef342 --- /dev/null +++ b/Tests/SwiftSyntaxTest/SyntaxTrackingTests.swift @@ -0,0 +1,161 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +@_spi(RawSyntax) import SwiftSyntax +import SwiftSyntaxBuilder +import XCTest + +public class SyntaxTrackingTests: XCTestCase { + func testReuseSubtreeWithoutNodeShiftInSameArena() { + let originalAccessorBlock = AccessorBlockSyntax("{ return 1 }").tracked + + let newAccessorBlock = AccessorBlockSyntax( + leadingTrivia: .spaces(10), + accessors: originalAccessorBlock.accessors + ) + + XCTAssertNotEqual(newAccessorBlock.accessors.id, originalAccessorBlock.accessors.id) + XCTAssertEqual( + newAccessorBlock.accessors.originalNode(in: originalAccessorBlock)?.id, + originalAccessorBlock.accessors.id + ) + } + + func testReuseSubtreeWithoutNodeShiftInNewArena() { + let originalAccessorBlock = AccessorBlockSyntax("{ return 1 }").tracked + + let newAccessorBlock = AccessorBlockSyntax( + leadingTrivia: .spaces(10), + accessors: originalAccessorBlock.accessors + ) + + XCTAssertEqual( + newAccessorBlock.accessors.originalNode(in: originalAccessorBlock)?.id, + originalAccessorBlock.accessors.id + ) + } + + func testReuseSubtreeWithNodeShift() { + let originalAccessorBlock = AccessorBlockSyntax("{ return 1 }").tracked + + let newAccessorBlock = AccessorBlockSyntax( + leadingTrivia: .spaces(10), + [Syntax(TokenSyntax.identifier("unexpected"))], + accessors: originalAccessorBlock.accessors + ) + + XCTAssertEqual( + newAccessorBlock.accessors.originalNode(in: originalAccessorBlock)?.id, + originalAccessorBlock.accessors.id + ) + } + + func testReplaceOtherNodeWithoutNodeShift() { + let originalAccessorBlock = AccessorBlockSyntax("{ return 1 }").tracked + + let newAccessor = originalAccessorBlock.with(\.leftBrace, .leftBraceToken()) + + XCTAssertEqual( + newAccessor.accessors.originalNode(in: originalAccessorBlock)?.id, + originalAccessorBlock.accessors.id + ) + } + + func testReplaceNonNilByNil() throws { + let originalFunction = try FunctionDeclSyntax("func foo() async {}").tracked + var modifiedFunction = originalFunction + modifiedFunction.signature.effectSpecifiers = nil + + XCTAssertEqual(modifiedFunction.body?.originalNode(in: originalFunction)?.id, originalFunction.body?.id) + } + + func testReplaceNilByNonNil() throws { + let originalFunction = try FunctionDeclSyntax("func foo() {}").tracked + var modifiedFunction = originalFunction + modifiedFunction.signature.effectSpecifiers = FunctionEffectSpecifiersSyntax(asyncSpecifier: .keyword(.async)) + + XCTAssertEqual(modifiedFunction.body?.originalNode(in: originalFunction)?.id, originalFunction.body?.id) + } + + func testReplaceNilByNil() throws { + let originalFunction = try FunctionDeclSyntax("func foo() {}").tracked + var modifiedFunction = originalFunction + modifiedFunction.signature.effectSpecifiers = nil + + XCTAssertEqual(modifiedFunction.body?.originalNode(in: originalFunction)?.id, originalFunction.body?.id) + } + + func testDetach() throws { + let originalFunction = try FunctionDeclSyntax("func foo() {}").tracked + let modifiedFunction = originalFunction.body?.detached + + XCTAssertEqual(modifiedFunction?.originalNode(in: originalFunction)?.id, originalFunction.body?.id) + } + + func testSyntaxCollection() throws { + let originalFunction = DeclSyntax("func foo() {}").tracked + + let codeBlockItemList = CodeBlockItemListSyntax([CodeBlockItemSyntax(item: .decl(originalFunction))]) + + XCTAssertEqual(codeBlockItemList.first?.item.originalNode(in: originalFunction)?.id, originalFunction.id) + } + + func testSyntaxCollectionModification() throws { + let originalFunction = DeclSyntax("func foo() {}").tracked + + var codeBlockItemList = CodeBlockItemListSyntax([CodeBlockItemSyntax(item: .decl(originalFunction))]) + codeBlockItemList.insert(CodeBlockItemSyntax("func bar() {}"), at: codeBlockItemList.startIndex) + + XCTAssertEqual(codeBlockItemList.last?.item.originalNode(in: originalFunction)?.id, originalFunction.id) + } + + func testTwoLayerModification() throws { + let originalFunction = try FunctionDeclSyntax("func foo() {}").tracked + let modifiedFunction = originalFunction.with(\.name, "bar") + let secondModification = modifiedFunction.with(\.body, nil) + + XCTAssertEqual( + secondModification.funcKeyword.originalNode(in: originalFunction)?.id, + originalFunction.funcKeyword.id + ) + XCTAssertNil(secondModification.name.originalNode(in: originalFunction)) + XCTAssertNil(secondModification.name.originalNode(in: modifiedFunction)) + } + + func testEditAndThenCreation() throws { + let originalFunction = try FunctionDeclSyntax("func foo() {}").tracked + let modifiedFunction = originalFunction.with(\.name, "bar") + + let codeBlockItem = CodeBlockItemSyntax(item: .decl(DeclSyntax(modifiedFunction))) + + XCTAssertEqual( + codeBlockItem.item.as(FunctionDeclSyntax.self)?.funcKeyword.originalNode(in: originalFunction)?.id, + originalFunction.funcKeyword.id + ) + XCTAssertNil(codeBlockItem.item.as(FunctionDeclSyntax.self)?.name.originalNode(in: originalFunction)?.id) + XCTAssertNil(codeBlockItem.item.as(FunctionDeclSyntax.self)?.name.originalNode(in: modifiedFunction)?.id) + } + + func testStartTrackingModifiedNode() throws { + let originalFunction = try FunctionDeclSyntax("func foo() {}").tracked + let modifiedFunction = originalFunction.with(\.name, "bar").tracked + let secondModification = modifiedFunction.with(\.body, nil) + + XCTAssertNil(secondModification.funcKeyword.originalNode(in: originalFunction)) + XCTAssertEqual( + secondModification.funcKeyword.originalNode(in: modifiedFunction)?.id, + modifiedFunction.funcKeyword.id + ) + XCTAssertNil(secondModification.name.originalNode(in: originalFunction)) + XCTAssertEqual(secondModification.name.originalNode(in: modifiedFunction)?.id, modifiedFunction.name.id) + } +}