diff --git a/CodeGeneration/Package.swift b/CodeGeneration/Package.swift index b0e19b463be..200a65fafb8 100644 --- a/CodeGeneration/Package.swift +++ b/CodeGeneration/Package.swift @@ -11,8 +11,8 @@ let package = Package( .executable(name: "generate-swiftsyntax", targets: ["generate-swiftsyntax"]) ], dependencies: [ - .package(url: "https://github.com/apple/swift-syntax.git", revision: "39b3336c3f3bfcd4ddbcbf6a111d8814ffe542f3"), - .package(url: "https://github.com/apple/swift-argument-parser.git", .upToNextMinor(from: "1.2.2")), + .package(url: "https://github.com/apple/swift-syntax.git", revision: "c7087adb193b26f02b59d21cd06d17ec202d1bf5"), + .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.2.2"), ], targets: [ .executableTarget( diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift index f9e245d877c..5d7fbaa35bb 100644 --- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift +++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift @@ -144,6 +144,7 @@ public let COMMON_NODES: [Node] = [ Node( name: "MissingDecl", nameForDiagnostics: "declaration", + description: "In case the source code is missing a declaration, this node stands in place of the missing declaration.", kind: "Decl", traits: [ "Attributed" @@ -152,44 +153,108 @@ public let COMMON_NODES: [Node] = [ Child( name: "Attributes", kind: .collection(kind: "AttributeList", collectionElementName: "Attribute"), + description: "If there were standalone attributes without a declaration to attach them to, the `MissingDeclSyntax` will contain these.", isOptional: true ), Child( name: "Modifiers", kind: .collection(kind: "ModifierList", collectionElementName: "Modifier"), + description: "If there were standalone modifiers without a declaration to attach them to, the `MissingDeclSyntax` will contain these.", isOptional: true ), + Child( + name: "Placeholder", + kind: .token(choices: [.token(tokenKind: "IdentifierToken")], requiresLeadingSpace: false, requiresTrailingSpace: false), + description: """ + A placeholder, i.e. `<#decl#>` that can be inserted into the source code to represent the missing declaration. + This token should always have `presence = .missing`. + """ + ), ] ), Node( name: "MissingExpr", nameForDiagnostics: "expression", - kind: "Expr" + description: "In case the source code is missing a expression, this node stands in place of the missing expression.", + kind: "Expr", + children: [ + Child( + name: "Placeholder", + kind: .token(choices: [.token(tokenKind: "IdentifierToken")], requiresLeadingSpace: false, requiresTrailingSpace: false), + description: """ + A placeholder, i.e. `<#expression#>` that can be inserted into the source code to represent the missing expression. + This token should always have `presence = .missing`. + """ + ) + ] ), Node( name: "MissingPattern", nameForDiagnostics: "pattern", - kind: "Pattern" + description: "In case the source code is missing a pattern, this node stands in place of the missing pattern.", + kind: "Pattern", + children: [ + Child( + name: "Placeholder", + kind: .token(choices: [.token(tokenKind: "IdentifierToken")], requiresLeadingSpace: false, requiresTrailingSpace: false), + description: """ + A placeholder, i.e. `<#pattern#>` that can be inserted into the source code to represent the missing pattern. + This token should always have `presence = .missing`. + """ + ) + ] ), Node( name: "MissingStmt", nameForDiagnostics: "statement", - kind: "Stmt" + description: "In case the source code is missing a statement, this node stands in place of the missing statement.", + kind: "Stmt", + children: [ + Child( + name: "Placeholder", + kind: .token(choices: [.token(tokenKind: "IdentifierToken")], requiresLeadingSpace: false, requiresTrailingSpace: false), + description: """ + A placeholder, i.e. `<#statement#>` that can be inserted into the source code to represent the missing pattern. + This token should always have `presence = .missing`. + """ + ) + ] ), Node( name: "Missing", nameForDiagnostics: nil, - kind: "Syntax" + description: "In case the source code is missing a syntax node, this node stands in place of the missing node.", + kind: "Syntax", + children: [ + Child( + name: "Placeholder", + kind: .token(choices: [.token(tokenKind: "IdentifierToken")], requiresLeadingSpace: false, requiresTrailingSpace: false), + description: """ + A placeholder, i.e. `<#syntax#>` that can be inserted into the source code to represent the missing pattern. + This token should always have `presence = .missing` + """ + ) + ] ), Node( name: "MissingType", nameForDiagnostics: "type", - kind: "Type" + description: "In case the source code is missing a type, this node stands in place of the missing type.", + kind: "Type", + children: [ + Child( + name: "Placeholder", + kind: .token(choices: [.token(tokenKind: "IdentifierToken")], requiresLeadingSpace: false, requiresTrailingSpace: false), + description: """ + A placeholder, i.e. `<#type#>` that can be inserted into the source code to represent the missing type. This token should always have `presence = .missing`. + """ + ) + ] ), Node( diff --git a/CodeGeneration/Sources/SyntaxSupport/Trivia.swift b/CodeGeneration/Sources/SyntaxSupport/Trivia.swift index 6f43a82befe..dee7b5a8c4e 100644 --- a/CodeGeneration/Sources/SyntaxSupport/Trivia.swift +++ b/CodeGeneration/Sources/SyntaxSupport/Trivia.swift @@ -15,7 +15,6 @@ public class Trivia { public let comment: String public let characters: [Character] public let swiftCharacters: [Character] - public let isNewLine: Bool public let isComment: Bool public var lowerName: String { lowercaseFirstWord(name: name) } @@ -36,17 +35,23 @@ public class Trivia { public var isCollection: Bool { charactersLen > 0 } + public var isBlank: Bool { + characters.contains { $0.isWhitespace } + } + + public var isNewLine: Bool { + characters.contains { $0.isNewline } + } + init( name: String, comment: String, characters: [Character] = [], swiftCharacters: [Character] = [], - isNewLine: Bool = false, isComment: Bool = false ) { self.name = name self.comment = comment - self.isNewLine = isNewLine self.isComment = isComment self.characters = characters @@ -86,8 +91,7 @@ public let TRIVIAS: [Trivia] = [ ], swiftCharacters: [ Character("\r") - ], - isNewLine: true + ] ), Trivia( @@ -100,8 +104,7 @@ public let TRIVIAS: [Trivia] = [ swiftCharacters: [ Character("\r"), Character("\n"), - ], - isNewLine: true + ] ), Trivia( @@ -142,8 +145,7 @@ public let TRIVIAS: [Trivia] = [ ], swiftCharacters: [ Character("\n") - ], - isNewLine: true + ] ), Trivia( diff --git a/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift b/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift index 7dfa451b5d7..361cc90e06e 100644 --- a/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift +++ b/CodeGeneration/Sources/Utils/CodeGenerationFormat.swift @@ -15,7 +15,13 @@ import SwiftSyntax /// A format style for files generated by CodeGeneration. public class CodeGenerationFormat: BasicFormat { - public override var indentation: TriviaPiece { .spaces(indentationLevel * 2) } + public init() { + super.init(indentationWidth: .spaces(2)) + } + + var indentedNewline: Trivia { + .newline + currentIndentationLevel + } public override func visit(_ node: ArrayElementListSyntax) -> ArrayElementListSyntax { let children = node.children(viewMode: .all) @@ -66,7 +72,7 @@ public class CodeGenerationFormat: BasicFormat { public override func visit(_ node: MemberDeclListItemSyntax) -> MemberDeclListItemSyntax { let formatted = super.visit(node) - if node.indexInParent != 0 && !node.decl.is(EnumCaseDeclSyntax.self) { + if node != node.parent?.children(viewMode: .sourceAccurate).first?.as(MemberDeclListItemSyntax.self) && !node.decl.is(EnumCaseDeclSyntax.self) { return ensuringTwoLeadingNewlines(node: formatted) } else { return formatted @@ -92,26 +98,26 @@ public class CodeGenerationFormat: BasicFormat { } private func ensuringTwoLeadingNewlines(node: NodeType) -> NodeType { - if node.leadingTrivia?.first?.isNewline ?? false { - return node.with(\.leadingTrivia, indentedNewline + (node.leadingTrivia ?? [])) + if node.leadingTrivia.first?.isNewline ?? false { + return node.with(\.leadingTrivia, indentedNewline + node.leadingTrivia) } else { - return node.with(\.leadingTrivia, indentedNewline + indentedNewline + (node.leadingTrivia ?? [])) + return node.with(\.leadingTrivia, indentedNewline + indentedNewline + node.leadingTrivia) } } private func formatChildrenSeparatedByNewline(children: SyntaxChildren, elementType: SyntaxType.Type) -> [SyntaxType] { - indentationLevel += 1 + increaseIndentationLevel() var formattedChildren = children.map { self.visit($0).as(SyntaxType.self)! } formattedChildren = formattedChildren.map { - if $0.leadingTrivia?.first?.isNewline == true { + if $0.leadingTrivia.first?.isNewline == true { return $0 } else { - return $0.with(\.leadingTrivia, indentedNewline + ($0.leadingTrivia ?? [])) + return $0.with(\.leadingTrivia, indentedNewline + $0.leadingTrivia) } } - indentationLevel -= 1 + decreaseIndentationLevel() if !formattedChildren.isEmpty { formattedChildren[formattedChildren.count - 1] = formattedChildren[formattedChildren.count - 1].with(\.trailingTrivia, indentedNewline) } diff --git a/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift b/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift index d2abf41adc5..39e3befd129 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/GenerateSwiftSyntax.swift @@ -80,7 +80,7 @@ struct GenerateSwiftSyntax: ParsableCommand { let fileSpecs: [GeneratedFileSpec] = [ // SwiftBasicFormat - GeneratedFileSpec(swiftBasicFormatGeneratedDir + ["BasicFormat.swift"], basicFormatFile), + GeneratedFileSpec(swiftBasicFormatGeneratedDir + ["BasicFormat+Extensions.swift"], basicFormatExtensionsFile), // IDEUtils GeneratedFileSpec(swiftIdeUtilsGeneratedDir + ["SyntaxClassification.swift"], syntaxClassificationFile), diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/basicformat/BasicFormatFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/basicformat/BasicFormatFile.swift deleted file mode 100644 index 05eeabd1119..00000000000 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/basicformat/BasicFormatFile.swift +++ /dev/null @@ -1,315 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -import SwiftSyntax -import SwiftSyntaxBuilder -import SyntaxSupport -import Utils - -extension Child { - var requiresLeadingSpace: Bool? { - switch self.kind { - case .token(_, let requiresLeadingSpace, _): - return requiresLeadingSpace - case .nodeChoices(let choices): - for choice in choices { - if let requiresLeadingSpace = choice.requiresLeadingSpace { - return requiresLeadingSpace - } - } - default: - break - } - return nil - } - - var requiresTrailingSpace: Bool? { - switch self.kind { - case .token(choices: _, _, let requiresTrailingSpace): - return requiresTrailingSpace - case .nodeChoices(let choices): - for choice in choices { - if let requiresTrailingSpace = choice.requiresTrailingSpace { - return requiresTrailingSpace - } - } - default: - break - } - return nil - } -} - -let basicFormatFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { - DeclSyntax("import SwiftSyntax") - - try! ClassDeclSyntax("open class BasicFormat: SyntaxRewriter") { - DeclSyntax("public var indentationLevel: Int = 0") - DeclSyntax("open var indentation: TriviaPiece { .spaces(indentationLevel * 4) }") - DeclSyntax("public var indentedNewline: Trivia { Trivia(pieces: [.newlines(1), indentation]) }") - DeclSyntax("private var lastRewrittenToken: TokenSyntax?") - DeclSyntax("private var putNextTokenOnNewLine: Bool = false") - - DeclSyntax( - """ - open override func visitPre(_ node: Syntax) { - if let keyPath = node.keyPathInParent, shouldIndent(keyPath) { - indentationLevel += 1 - } - if let parent = node.parent, childrenSeparatedByNewline(parent) { - putNextTokenOnNewLine = true && node.previousToken(viewMode: .sourceAccurate) != nil - } - } - """ - ) - DeclSyntax( - """ - open override func visitPost(_ node: Syntax) { - if let keyPath = node.keyPathInParent, shouldIndent(keyPath) { - indentationLevel -= 1 - } - } - """ - ) - - DeclSyntax( - """ - open override func visit(_ node: TokenSyntax) -> TokenSyntax { - var leadingTrivia = node.leadingTrivia - var trailingTrivia = node.trailingTrivia - if requiresLeadingSpace(node) && leadingTrivia.isEmpty && lastRewrittenToken?.trailingTrivia.isEmpty != false { - leadingTrivia += .space - } - if requiresTrailingSpace(node) && trailingTrivia.isEmpty { - trailingTrivia += .space - } - if let keyPath = node.keyPathInParent, requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) { - leadingTrivia = .newline + leadingTrivia - } - var isOnNewline: Bool = (lastRewrittenToken?.trailingTrivia.pieces.last?.isNewline == true) - if case .stringSegment(let text) = lastRewrittenToken?.tokenKind { - isOnNewline = isOnNewline || (text.last?.isNewline == true) - } - leadingTrivia = leadingTrivia.indented(indentation: indentation, isOnNewline: isOnNewline) - let rewritten = TokenSyntax( - node.tokenKind, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: node.presence - ) - lastRewrittenToken = rewritten - putNextTokenOnNewLine = false - return rewritten - } - """ - ) - - DeclSyntax( - """ - /// If this returns `true`, ``BasicFormat`` will not wrap `node` to a new line. This can be used to e.g. keep string interpolation segments on a single line. - /// - Parameter node: the node that is being visited - /// - Returns: returns true if newline should be omitted - open func shouldOmitNewline(_ node: TokenSyntax) -> Bool { - if node.previousToken(viewMode: .sourceAccurate) == nil { - return true - } - var ancestor: Syntax = Syntax(node) - while let parent = ancestor.parent { - ancestor = parent - if ancestor.is(ExpressionSegmentSyntax.self) { - return true - } - } - - return false - } - """ - ) - - try FunctionDeclSyntax("open func shouldIndent(_ keyPath: AnyKeyPath) -> Bool") { - try SwitchExprSyntax("switch keyPath") { - for node in SYNTAX_NODES where !node.isBase { - for child in node.children where child.isIndented { - SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { - StmtSyntax("return true") - } - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return false") - } - } - } - - try FunctionDeclSyntax("open func requiresLeadingNewline(_ keyPath: AnyKeyPath) -> Bool") { - try SwitchExprSyntax("switch keyPath") { - for node in SYNTAX_NODES where !node.isBase { - for child in node.children where child.requiresLeadingNewline { - SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { - StmtSyntax("return true") - } - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return putNextTokenOnNewLine") - } - } - } - - try FunctionDeclSyntax("open func childrenSeparatedByNewline(_ node: Syntax) -> Bool") { - try SwitchExprSyntax("switch node.as(SyntaxEnum.self)") { - for node in SYNTAX_NODES where !node.isBase { - if node.elementsSeparatedByNewline { - SwitchCaseSyntax("case .\(raw: node.swiftSyntaxKind):") { - StmtSyntax("return true") - } - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return false") - } - } - } - - try FunctionDeclSyntax( - """ - /// If this returns a value that is not `nil`, it overrides the default - /// leading space behavior of a token. - open func requiresLeadingSpace(_ keyPath: AnyKeyPath) -> Bool? - """ - ) { - try SwitchExprSyntax("switch keyPath") { - for node in SYNTAX_NODES where !node.isBase { - for child in node.children { - if let requiresLeadingSpace = child.requiresLeadingSpace { - SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { - StmtSyntax("return \(literal: requiresLeadingSpace)") - } - } - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return nil") - } - } - } - - try FunctionDeclSyntax("open func requiresLeadingSpace(_ token: TokenSyntax) -> Bool") { - StmtSyntax( - """ - if let keyPath = token.keyPathInParent, let requiresLeadingSpace = requiresLeadingSpace(keyPath) { - return requiresLeadingSpace - } - """ - ) - - StmtSyntax( - """ - switch (token.previousToken(viewMode: .sourceAccurate)?.tokenKind, token.tokenKind) { - case (.leftParen, .leftBrace): // Ensures there is not a space in `.map({ $0.foo })` - return false - default: - break - } - """ - ) - - try SwitchExprSyntax("switch token.tokenKind") { - for token in SYNTAX_TOKENS { - if token.requiresLeadingSpace { - SwitchCaseSyntax("case .\(raw: token.swiftKind):") { - StmtSyntax("return true") - } - } - } - for keyword in KEYWORDS where keyword.requiresLeadingSpace { - SwitchCaseSyntax("case .keyword(.\(raw: keyword.escapedName)):") { - StmtSyntax("return true") - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return false") - } - } - } - - try FunctionDeclSyntax( - """ - /// If this returns a value that is not `nil`, it overrides the default - /// trailing space behavior of a token. - open func requiresTrailingSpace(_ keyPath: AnyKeyPath) -> Bool? - """ - ) { - try SwitchExprSyntax("switch keyPath") { - for node in SYNTAX_NODES where !node.isBase { - for child in node.children { - if let requiresTrailingSpace = child.requiresTrailingSpace { - SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { - StmtSyntax("return \(literal: requiresTrailingSpace)") - } - } - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return nil") - } - } - } - - try FunctionDeclSyntax("open func requiresTrailingSpace(_ token: TokenSyntax) -> Bool") { - StmtSyntax( - """ - if let keyPath = token.keyPathInParent, let requiresTrailingSpace = requiresTrailingSpace(keyPath) { - return requiresTrailingSpace - } - """ - ) - - StmtSyntax( - """ - switch (token.tokenKind, token.nextToken(viewMode: .sourceAccurate)?.tokenKind) { - case (.exclamationMark, .leftParen), // Ensures there is not a space in `myOptionalClosure!()` - (.exclamationMark, .period), // Ensures there is not a space in `myOptionalBar!.foo()` - (.keyword(.as), .exclamationMark), // Ensures there is not a space in `as!` - (.keyword(.as), .postfixQuestionMark), // Ensures there is not a space in `as?` - (.keyword(.try), .exclamationMark), // Ensures there is not a space in `try!` - (.keyword(.try), .postfixQuestionMark), // Ensures there is not a space in `try?`: - (.postfixQuestionMark, .leftParen), // Ensures there is not a space in `init?()` or `myOptionalClosure?()`s - (.postfixQuestionMark, .rightAngle), // Ensures there is not a space in `ContiguousArray` - (.postfixQuestionMark, .rightParen): // Ensures there is not a space in `myOptionalClosure?()` - return false - default: - break - } - """ - ) - - try SwitchExprSyntax("switch token.tokenKind") { - for token in SYNTAX_TOKENS { - if token.requiresTrailingSpace { - SwitchCaseSyntax("case .\(raw: token.swiftKind):") { - StmtSyntax("return true") - } - } - } - for keyword in KEYWORDS where keyword.requiresTrailingSpace { - SwitchCaseSyntax("case .keyword(.\(raw: keyword.escapedName)):") { - StmtSyntax("return true") - } - } - SwitchCaseSyntax("default:") { - StmtSyntax("return false") - } - } - } - } -} diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftbasicformat/BasicFormatExtensionsFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftbasicformat/BasicFormatExtensionsFile.swift new file mode 100644 index 00000000000..e56a80f5ddd --- /dev/null +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftbasicformat/BasicFormatExtensionsFile.swift @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax +import SwiftSyntaxBuilder +import SyntaxSupport +import Utils + +extension Child { + var requiresLeadingSpace: Bool? { + switch self.kind { + case .token(_, let requiresLeadingSpace, _): + return requiresLeadingSpace + case .nodeChoices(let choices): + for choice in choices { + if let requiresLeadingSpace = choice.requiresLeadingSpace { + return requiresLeadingSpace + } + } + default: + break + } + return nil + } + + var requiresTrailingSpace: Bool? { + switch self.kind { + case .token(choices: _, _, let requiresTrailingSpace): + return requiresTrailingSpace + case .nodeChoices(let choices): + for choice in choices { + if let requiresTrailingSpace = choice.requiresTrailingSpace { + return requiresTrailingSpace + } + } + default: + break + } + return nil + } +} + +let basicFormatExtensionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { + DeclSyntax("import SwiftSyntax") + + try! ExtensionDeclSyntax("public extension SyntaxProtocol") { + DeclSyntax( + """ + var requiresIndent: Bool { + guard let keyPath = keyPathInParent else { + return false + } + return keyPath.requiresIndent + } + """ + ) + } + + try! ExtensionDeclSyntax("public extension TokenSyntax") { + DeclSyntax( + """ + var requiresLeadingNewline: Bool { + if let keyPath = keyPathInParent, keyPath.requiresLeadingNewline { + return true + } + return false + } + """ + ) + } + + try! ExtensionDeclSyntax("fileprivate extension AnyKeyPath") { + try VariableDeclSyntax("var requiresIndent: Bool") { + try SwitchExprSyntax("switch self") { + for node in SYNTAX_NODES where !node.isBase { + for child in node.children where child.isIndented { + SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { + StmtSyntax("return true") + } + } + } + SwitchCaseSyntax("default:") { + StmtSyntax("return false") + } + } + } + + try VariableDeclSyntax("var requiresLeadingNewline: Bool") { + try SwitchExprSyntax("switch self") { + for node in SYNTAX_NODES where !node.isBase { + for child in node.children where child.requiresLeadingNewline { + SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { + StmtSyntax("return true") + } + } + } + SwitchCaseSyntax("default:") { + StmtSyntax("return false") + } + } + } + + try VariableDeclSyntax("var requiresLeadingSpace: Bool?") { + try SwitchExprSyntax("switch self") { + for node in SYNTAX_NODES where !node.isBase { + for child in node.children { + if let requiresLeadingSpace = child.requiresLeadingSpace { + SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { + StmtSyntax("return \(literal: requiresLeadingSpace)") + } + } + } + } + SwitchCaseSyntax("default:") { + StmtSyntax("return nil") + } + } + } + + try VariableDeclSyntax("var requiresTrailingSpace: Bool?") { + try SwitchExprSyntax("switch self") { + for node in SYNTAX_NODES where !node.isBase { + for child in node.children { + if let requiresTrailingSpace = child.requiresTrailingSpace { + SwitchCaseSyntax("case \\\(raw: node.type.syntaxBaseName).\(raw: child.swiftName):") { + StmtSyntax("return \(literal: requiresTrailingSpace)") + } + } + } + } + SwitchCaseSyntax("default:") { + StmtSyntax("return nil") + } + } + } + } +} diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserEntryFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserEntryFile.swift index 6ce81f5a9dc..4480973a059 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserEntryFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftparser/ParserEntryFile.swift @@ -88,10 +88,10 @@ let parserEntryFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { let existingUnexpected: [RawSyntax] if let unexpectedNode = layout.children[layout.children.count - 1] { - precondition(unexpectedNode.is(RawUnexpectedNodesSyntax.self)) - existingUnexpected = unexpectedNode.as(RawUnexpectedNodesSyntax.self).elements + precondition(unexpectedNode.is(RawUnexpectedNodesSyntax.self)) + existingUnexpected = unexpectedNode.as(RawUnexpectedNodesSyntax.self).elements } else { - existingUnexpected = [] + existingUnexpected = [] } let unexpected = RawUnexpectedNodesSyntax(elements: existingUnexpected + remainingTokens, arena: self.arena) diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxNodesFile.swift index 1039fd01630..c0292836ce8 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxNodesFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxNodesFile.swift @@ -169,11 +169,11 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { public init(elements: [\(raw: element)], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( kind: .\(raw: node.swiftSyntaxKind), uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { return } - for elem in elements { - ptr.initialize(to: elem.raw) - ptr += 1 - } + guard var ptr = layout.baseAddress else { return } + for elem in elements { + ptr.initialize(to: elem.raw) + ptr += 1 + } } self.init(unchecked: raw) } @@ -183,7 +183,7 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { DeclSyntax( """ public var elements: [Raw\(raw: node.collectionElementType.syntaxBaseName)] { - layoutView.children.map { Raw\(raw: node.collectionElementType.syntaxBaseName)(raw: $0!) } + layoutView.children.map { Raw\(raw: node.collectionElementType.syntaxBaseName)(raw: $0!) } } """ ) @@ -193,15 +193,15 @@ let rawSyntaxNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { let params = FunctionParameterListSyntax { for child in node.children { FunctionParameterSyntax( - firstName: child.isUnexpectedNodes ? .wildcardToken(trailingTrivia: .space) : nil, - secondName: .identifier(child.swiftName), + firstName: child.isUnexpectedNodes ? .wildcardToken(trailingTrivia: .space) : .identifier(child.swiftName), + secondName: child.isUnexpectedNodes ? .identifier(child.swiftName) : nil, colon: .colonToken(), type: child.rawParameterType, defaultArgument: child.isUnexpectedNodes ? child.defaultInitialization : nil ) } - FunctionParameterSyntax("arena: __shared SyntaxArena", for: .functionParameters) + FunctionParameterSyntax("arena: __shared SyntaxArena") } try InitializerDeclSyntax("public init(\(params))") { if !node.children.isEmpty { diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxValidationFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxValidationFile.swift index f1ef575e906..bb21e1573f1 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxValidationFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/RawSyntaxValidationFile.swift @@ -35,18 +35,18 @@ let rawSyntaxValidationFile = try! SourceFileSyntax(leadingTrivia: copyrightHead DeclSyntax( #""" enum TokenChoice: CustomStringConvertible { - case keyword(StaticString) - case tokenKind(RawTokenKind) + case keyword(StaticString) + case tokenKind(RawTokenKind) - var description: String { - switch self { - case .keyword(let keyword): - return "keyword('\(keyword)')" - case .tokenKind(let kind): - return "\(kind)" - } - } - } + var description: String { + switch self { + case .keyword(let keyword): + return "keyword('\(keyword)')" + case .tokenKind(let kind): + return "\(kind)" + } + } + } """# ) @@ -76,7 +76,7 @@ let rawSyntaxValidationFile = try! SourceFileSyntax(leadingTrivia: copyrightHead return (file, line) case .tokenMismatch(expectedTokenChoices: _, actualKind: _, actualText: _, file: let file, line: let line): return (file, line) - } + } } } """# @@ -156,13 +156,13 @@ let rawSyntaxValidationFile = try! SourceFileSyntax(leadingTrivia: copyrightHead DeclSyntax( #""" - func assertNoError(_ nodeKind: SyntaxKind, _ index: Int, _ error: ValidationError?) { - if let error = error { - let (file, line) = error.fileAndLine - assertionFailure(""" - Error validating child at index \(index) of \(nodeKind): - \(error.description) - """, file: file, line: line) + func assertNoError(_ nodeKind: SyntaxKind, _ index: Int, _ error: ValidationError?) { + if let error = error { + let (file, line) = error.fileAndLine + assertionFailure(""" + Error validating child at index \(index) of \(nodeKind): + \(error.description) + """, file: file, line: line) } } """# diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift index 601a9fc5bcb..4eb556246af 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxCollectionsFile.swift @@ -191,13 +191,12 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `\(raw: node.name)` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> \(raw: node.name) { - let arena = SyntaxArena() - let newRaw = layoutView.replacingLayout(with: layout, arena: arena) - let newData = data.replacingSelf(newRaw, arena: arena) - return \(raw: node.name)(newData) - } + internal func replacingLayout(_ layout: [RawSyntax?]) -> \(raw: node.name) { + let arena = SyntaxArena() + let newRaw = layoutView.replacingLayout(with: layout, arena: arena) + let newData = data.replacingSelf(newRaw, arena: arena) + return \(raw: node.name)(newData) + } """ ) diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodeFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift similarity index 91% rename from CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodeFile.swift rename to CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift index d3927d654b7..60a3c4734d4 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodeFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxNodesFile.swift @@ -15,6 +15,18 @@ import SwiftSyntaxBuilder import SyntaxSupport import Utils +extension Child { + public var docComment: SwiftSyntax.Trivia { + guard let description = description else { + return [] + } + let dedented = dedented(string: description) + let lines = dedented.split(separator: "\n", omittingEmptySubsequences: false) + let pieces = lines.map { SwiftSyntax.TriviaPiece.docLineComment("/// \($0)") } + return Trivia(pieces: pieces) + } +} + /// This file generates the syntax nodes for SwiftSyntax. To keep the generated /// files at a managable file size, it is to be invoked multiple times with the /// variable `emitKind` set to a base kind listed in @@ -33,7 +45,7 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax { """ ) { for child in node.children { - if let childChoiceDecl = try generateSyntaxChildChoices(for: child) { + if let childChoiceDecl = try! generateSyntaxChildChoices(for: child) { childChoiceDecl } } @@ -66,18 +78,20 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax { ) try! InitializerDeclSyntax("\(node.generateInitializerDeclHeader(optionalBaseAsMissing: false))") { - let parameters = FunctionParameterListSyntax { + let parameters = ClosureParameterListSyntax { for child in node.children { - FunctionParameterSyntax(firstName: "\(raw: child.swiftName)") + ClosureParameterSyntax(firstName: .identifier(child.swiftName)) } } let closureSignature = ClosureSignatureSyntax( input: .input( - ParameterClauseSyntax { - FunctionParameterSyntax(firstName: .identifier("arena")) - FunctionParameterSyntax(firstName: .wildcardToken()) - } + ClosureParameterClauseSyntax( + parameterList: ClosureParameterListSyntax { + ClosureParameterSyntax(firstName: .identifier("arena")) + ClosureParameterSyntax(firstName: .wildcardToken()) + } + ) ) ) let layoutList = ArrayExprSyntax { @@ -107,8 +121,12 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax { DeclSyntax( """ let raw = RawSyntax.makeLayout( - kind: SyntaxKind.\(raw: node.swiftSyntaxKind), from: layout, arena: arena, - leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia) + kind: SyntaxKind.\(raw: node.swiftSyntaxKind), + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + ) """ ) } @@ -134,7 +152,7 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax { if node.hasOptionalBaseTypeChild { // TODO: Remove when we no longer support compiling in Swift 5.6. Change the // above constructor to use `Optional.none` instead. - try InitializerDeclSyntax( + try! InitializerDeclSyntax( """ /// This initializer exists solely because Swift 5.6 does not support /// `Optional.none` as a default value of a generic parameter. @@ -185,11 +203,10 @@ func syntaxNode(emitKind: String) -> SourceFileSyntax { let childType: String = child.kind.isNodeChoicesEmpty ? child.typeName : child.name let type = child.isOptional ? TypeSyntax("\(raw: childType)?") : TypeSyntax("\(raw: childType)") - let childDoc = child.description.map { dedented(string: $0) }.map { Trivia.docLineComment("/// \($0)") } - try VariableDeclSyntax( + try! VariableDeclSyntax( """ - \(raw: childDoc ?? []) + \(raw: child.docComment) public var \(raw: child.swiftName): \(type) """ ) { @@ -268,7 +285,7 @@ private func generateSyntaxChildChoices(for child: Child) throws -> EnumDeclSynt return nil } - return try EnumDeclSyntax("public enum \(raw: child.name): SyntaxChildChoices") { + return try! EnumDeclSyntax("public enum \(raw: child.name): SyntaxChildChoices") { for choice in choices { DeclSyntax("case `\(raw: choice.swiftName)`(\(raw: choice.typeName))") } @@ -384,13 +401,13 @@ fileprivate extension Node { } let params = FunctionParameterListSyntax { - FunctionParameterSyntax("leadingTrivia: Trivia? = nil", for: .functionParameters) + FunctionParameterSyntax("leadingTrivia: Trivia? = nil") for child in children { createFunctionParameterSyntax(for: child) } - FunctionParameterSyntax("trailingTrivia: Trivia? = nil", for: .functionParameters) + FunctionParameterSyntax("trailingTrivia: Trivia? = nil") .with(\.leadingTrivia, .newline) } diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift index 2f03b156e69..2b9b79d089f 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/SyntaxRewriterFile.swift @@ -335,5 +335,17 @@ let syntaxRewriterFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { } """ ) + + DeclSyntax( + """ + /// Rewrite `node` and anchor, making sure that the rewritten node also has + /// a parent if `node` had one. + public func rewrite(_ node: Syntax) -> Syntax { + let rewritten = self.visit(node) + let arena = SyntaxArena() + return Syntax(node.data.replacingSelf(rewritten.raw, arena: arena)) + } + """ + ) } } diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift index 355a54563a7..e32c9883867 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntax/TriviaPiecesFile.swift @@ -181,7 +181,7 @@ let triviaPiecesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { ) { for trivia in TRIVIAS { if trivia.isCollection { - DeclSyntax(" case \(raw: trivia.enumCaseName)(Int)") + DeclSyntax("case \(raw: trivia.enumCaseName)(Int)") } else { DeclSyntax("case \(raw: trivia.enumCaseName)(SyntaxText)") @@ -264,4 +264,51 @@ let triviaPiecesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) { } } } + + try! generateIsHelpers(for: "TriviaPiece") + + try! generateIsHelpers(for: "RawTriviaPiece") +} + +fileprivate func generateIsHelpers(for pieceName: String) throws -> ExtensionDeclSyntax { + return try ExtensionDeclSyntax("extension \(raw: pieceName)") { + DeclSyntax( + """ + /// Returns `true` if this piece is a newline, space or tab. + public var isWhitespace: Bool { + return isSpaceOrTab || isNewline + } + """ + ) + + try VariableDeclSyntax("public var isNewline: Bool") { + try SwitchExprSyntax("switch self") { + for trivia in TRIVIAS { + if trivia.isNewLine { + SwitchCaseSyntax("case .\(raw: trivia.enumCaseName):") { + StmtSyntax("return true") + } + } + } + SwitchCaseSyntax("default:") { + StmtSyntax("return false") + } + } + } + + DeclSyntax( + """ + public var isSpaceOrTab: Bool { + switch self { + case .spaces: + return true + case .tabs: + return true + default: + return false + } + } + """ + ) + } } diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableCollectionNodesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableCollectionNodesFile.swift index a6288c271b4..d6c021fa8e9 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableCollectionNodesFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableCollectionNodesFile.swift @@ -30,7 +30,9 @@ let buildableCollectionNodesFile = SourceFileSyntax(leadingTrivia: copyrightHead DeclSyntax( """ public init(_ elements: \(ArrayTypeSyntax(elementType: elementType.parameterType))) { - self = \(raw: node.type.syntaxBaseName)(elements.map { \(elementType.syntax)(fromProtocol: $0) }) + self = \(raw: node.type.syntaxBaseName)(elements.map { + \(elementType.syntax)(fromProtocol: $0) + }) } """ ) diff --git a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift index fd155fa7f65..e6eb669c31f 100644 --- a/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift +++ b/CodeGeneration/Sources/generate-swiftsyntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift @@ -71,10 +71,7 @@ private func createConvenienceInitializer(node: Node) throws -> InitializerDeclS produceExpr = ExprSyntax("\(raw: child.swiftName)Builder()") } builderParameters.append( - FunctionParameterSyntax( - "@\(raw: builderInitializableType.resultBuilderBaseName) \(raw: child.swiftName)Builder: () throws-> \(raw: builderInitializableType.syntax)", - for: .functionParameters - ) + FunctionParameterSyntax("@\(raw: builderInitializableType.resultBuilderBaseName) \(raw: child.swiftName)Builder: () throws-> \(raw: builderInitializableType.syntax)") ) } else { produceExpr = convertFromSyntaxProtocolToSyntaxType(child: child) @@ -95,11 +92,11 @@ private func createConvenienceInitializer(node: Node) throws -> InitializerDeclS } let params = ParameterClauseSyntax { - FunctionParameterSyntax("leadingTrivia: Trivia? = nil", for: .functionParameters) + FunctionParameterSyntax("leadingTrivia: Trivia? = nil") for param in normalParameters + builderParameters { param } - FunctionParameterSyntax("trailingTrivia: Trivia? = nil", for: .functionParameters) + FunctionParameterSyntax("trailingTrivia: Trivia? = nil") } return try InitializerDeclSyntax( diff --git a/Package.swift b/Package.swift index 46ad9df8342..48137482a52 100644 --- a/Package.swift +++ b/Package.swift @@ -90,6 +90,11 @@ let package = Package( exclude: ["CMakeLists.txt"] ), + .testTarget( + name: "SwiftBasicFormatTest", + dependencies: ["_SwiftSyntaxTestSupport", "SwiftBasicFormat", "SwiftSyntaxBuilder"] + ), + // MARK: SwiftCompilerPlugin .target( diff --git a/Sources/SwiftBasicFormat/BasicFormat.swift b/Sources/SwiftBasicFormat/BasicFormat.swift new file mode 100644 index 00000000000..4f4c6847a95 --- /dev/null +++ b/Sources/SwiftBasicFormat/BasicFormat.swift @@ -0,0 +1,395 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax + +open class BasicFormat: SyntaxRewriter { + /// How much indentation should be added at a new indentation level. + public let indentationWidth: Trivia + + /// As we reach a new indendation level, its indentation will be added to the + /// stack. As we exit that indentation level, the indendation will be popped. + /// `isUserDefined` is `true` if the indentation was inferred from something + /// the user provided manually instead of being inferred from the nesting + /// level. + public var indentationStack: [(indentation: Trivia, isUserDefined: Bool)] + + /// The trivia by which tokens should currently be indented. + public var currentIndentationLevel: Trivia { + // `decreaseIndentationLevel` guarantees that there is always one item on the stack. + return indentationStack.last!.indentation + } + + /// For every token that is being put on a new line but did not have + /// user-specified indentation, the generated indentation. + /// + /// This is used as a reference-point to indent user-indented code. + private var anchorPoints: [TokenSyntax: Trivia] = [:] + + public let viewMode: SyntaxTreeViewMode + + /// The previously visited token. This is faster than accessing + /// `token.previousToken` inside `visit(_:TokenSyntax)`. `nil` if no token has + /// been visited yet. + private var previousToken: TokenSyntax? = nil + + public init( + indentationWidth: Trivia = .spaces(4), + initialIndentation: Trivia = [], + viewMode: SyntaxTreeViewMode = .sourceAccurate + ) { + self.indentationWidth = indentationWidth + self.indentationStack = [(indentation: initialIndentation, isUserDefined: false)] + self.viewMode = viewMode + } + + // MARK: - Updating indentation level + + public func increaseIndentationLevel(to userDefinedIndentation: Trivia? = nil) { + if let userDefinedIndentation = userDefinedIndentation { + indentationStack.append((indentation: userDefinedIndentation, isUserDefined: true)) + } else { + indentationStack.append((indentation: currentIndentationLevel + indentationWidth, isUserDefined: false)) + } + } + + public func decreaseIndentationLevel() { + if indentationStack.count == 1 { + assertionFailure("Popping more indentation levels than have been pushed") + return + } + indentationStack.removeLast() + } + + open override func visitPre(_ node: Syntax) { + if requiresIndent(node) { + if let firstToken = node.firstToken(viewMode: viewMode), + let tokenIndentation = firstToken.leadingTrivia.indentation(isOnNewline: false), + !tokenIndentation.isEmpty, + let lastNonUserDefinedIndentation = indentationStack.last(where: { !$0.isUserDefined })?.indentation + { + // If the first token in this block is indented, infer the indentation level from it. + increaseIndentationLevel(to: lastNonUserDefinedIndentation + tokenIndentation) + } else { + increaseIndentationLevel() + } + } + } + + open override func visitPost(_ node: Syntax) { + if requiresIndent(node) { + decreaseIndentationLevel() + } + } + + // MARK: - Helper functions + + private func isInsideStringInterpolation(_ token: TokenSyntax) -> Bool { + var ancestor: Syntax = Syntax(token) + while let parent = ancestor.parent { + ancestor = parent + if ancestor.is(ExpressionSegmentSyntax.self) { + return true + } + } + return false + } + + private func childrenSeparatedByNewline(_ node: Syntax) -> Bool { + switch node.as(SyntaxEnum.self) { + case .accessorList: + return true + case .codeBlockItemList: + return true + case .ifConfigClauseList: + return true + case .memberDeclList: + return true + case .switchCaseList: + return true + default: + return false + } + } + + /// Find the indentation of the nearest ancestor whose first token is an + /// anchor point (see `anchorPoints`). + private func anchorPointIndentation(for token: TokenSyntax) -> Trivia? { + var ancestor: Syntax = Syntax(token) + while let parent = ancestor.parent { + ancestor = parent + if let firstToken = parent.firstToken(viewMode: viewMode), + let anchorPointIndentation = anchorPoints[firstToken] + { + return anchorPointIndentation + } + } + return nil + } + + // MARK: - Customization points + + /// Whether a leading newline on `token` should be added. + open func requiresIndent(_ node: T) -> Bool { + return node.requiresIndent + } + + /// Whether a leading newline on `token` should be added. + open func requiresLeadingNewline(_ token: TokenSyntax) -> Bool { + // We don't want to add newlines inside string interpolation + if isInsideStringInterpolation(token) { + return false + } + + if token.requiresLeadingNewline { + return true + } + + var ancestor: Syntax = Syntax(token) + while let parent = ancestor.parent { + ancestor = parent + if ancestor.position != token.position || ancestor.firstToken(viewMode: viewMode) != token { + break + } + if let ancestorsParent = ancestor.parent, childrenSeparatedByNewline(ancestorsParent) { + return true + } + switch ancestor.keyPathInParent { + case \IfConfigClauseSyntax.elements: + return true + default: + break + } + } + + return false + } + + open func requiresWhitespace(between first: TokenSyntax?, and second: TokenSyntax?) -> Bool { + switch (first?.tokenKind, second?.tokenKind) { + case (.atSign, _), + (.backslash, _), + (.backtick, _), + (.dollarIdentifier, .period), // a.b + (.eof, _), + (.exclamationMark, .leftParen), // myOptionalClosure!() + (.exclamationMark, .period), // myOptionalBar!.foo() + (.extendedRegexDelimiter, .leftParen), // opening extended regex delimiter should never be separate by a space + (.extendedRegexDelimiter, .regexSlash), // opening extended regex delimiter should never be separate by a space + (.identifier, .leftAngle), // MyType + (.identifier, .leftParen), // foo() + (.identifier, .leftSquareBracket), // myArray[1] + (.identifier, .period), // a.b + (.integerLiteral, .period), // macOS 11.2.1 + (.keyword(.`init`), .leftAngle), // init() + (.keyword(.`init`), .leftParen), // init() + (.keyword(.self), .period), // self.someProperty + (.keyword(.Self), .period), // self.someProperty + (.keyword(.set), .leftParen), // var mYar: Int { set(value) {} } + (.keyword(.subscript), .leftParen), // subscript(x: Int) + (.keyword(.super), .period), // super.someProperty + (.leftBrace, _), + (.leftParen, _), + (.leftSquareBracket, _), + (.multilineStringQuote, .rawStringDelimiter), // closing raw string delimiter should never be separate by a space + (.period, _), + (.postfixQuestionMark, .leftAngle), // init?() + (.postfixQuestionMark, .leftParen), // init?() or myOptionalClosure?() + (.postfixQuestionMark, .period), // someOptional?.someProperty + (.pound, _), + (.poundUnavailableKeyword, .leftParen), // #unavailable(...) + (.prefixAmpersand, _), + (.prefixOperator, _), + (.rawStringDelimiter, .leftParen), // opening raw string delimiter should never be separate by a space + (.rawStringDelimiter, .multilineStringQuote), // opening raw string delimiter should never be separate by a space + (.rawStringDelimiter, .singleQuote), // opening raw string delimiter should never be separate by a space + (.rawStringDelimiter, .stringQuote), // opening raw string delimiter should never be separate by a space + (.regexLiteralPattern, _), + (.regexSlash, .extendedRegexDelimiter), // closing extended regex delimiter should never be separate by a space + (.rightAngle, .leftParen), // func foo(x: T) + (.rightParen, .leftParen), // returnsClosure()() + (.rightParen, .period), // foo().bar + (.rightSquareBracket, .period), // myArray[1].someProperty + (.singleQuote, .rawStringDelimiter), // closing raw string delimiter should never be separate by a space + (.stringQuote, .rawStringDelimiter), // closing raw string delimiter should never be separate by a space + (.stringSegment, _), + (_, .colon), + (_, .comma), + (_, .ellipsis), + (_, .eof), + (_, .exclamationMark), + (_, .postfixOperator), + (_, .postfixQuestionMark), + (_, .rightBrace), + (_, .rightParen), + (_, .rightSquareBracket), + (_, .semicolon), + (_, nil), + (nil, _): + return false + case (.leftAngle, _) where second?.tokenKind != .rightAngle: // `<` and `>` need to be separated by a space because otherwise they become an operator + return false + case (_, .rightAngle) where first?.tokenKind != .leftAngle: // `<` and `>` need to be separated by a space because otherwise they become an operator + return false + default: + break + } + + switch first?.keyPathInParent { + case \ExpressionSegmentSyntax.backslash, + \ExpressionSegmentSyntax.rightParen, + \DeclNameArgumentSyntax.colon, + \StringLiteralExprSyntax.openQuote, + \RegexLiteralExprSyntax.openSlash: + return false + default: + break + } + + return true + } + + /// Whether the formatter should consider this token as being mutable. + /// This allows the diagnostic generator to only assume that missing nodes + /// will be mutated. Thus, if two tokens need to be separated by a space, it + /// will not be assumed that the space is added to an immutable previous node. + open func isMutable(_ token: TokenSyntax) -> Bool { + return true + } + + // MARK: - Formatting a token + + open override func visit(_ token: TokenSyntax) -> TokenSyntax { + defer { + self.previousToken = token + } + let previousToken = self.previousToken ?? token.previousToken(viewMode: viewMode) + let nextToken = token.nextToken(viewMode: viewMode) + + lazy var previousTokenWillEndWithWhitespace: Bool = { + guard let previousToken = previousToken else { + return false + } + return previousToken.trailingTrivia.endsWithWhitespace + || (requiresWhitespace(between: previousToken, and: token) && isMutable(previousToken)) + }() + + lazy var previousTokenWillEndWithNewline: Bool = { + guard let previousToken = previousToken else { + // Assume that the start of the tree is equivalent to a newline so we + // don't add a leading newline to the file. + return true + } + if previousToken.trailingTrivia.endsWithNewline { + return true + } + if case .stringSegment(let segment) = previousToken.tokenKind, segment.last?.isNewline ?? false { + return true + } + return false + }() + + lazy var previousTokenIsStringLiteralEndingInNewline: Bool = { + guard let previousToken = previousToken else { + // Assume that the start of the tree is equivalent to a newline so we + // don't add a leading newline to the file. + return true + } + if case .stringSegment(let segment) = previousToken.tokenKind, segment.last?.isNewline ?? false { + return true + } + return false + }() + + lazy var nextTokenWillStartWithNewline: Bool = { + guard let nextToken = nextToken else { + return false + } + return nextToken.leadingTrivia.startsWithNewline + || (requiresLeadingNewline(nextToken) && isMutable(nextToken)) + }() + + /// This token's trailing trivia + any spaces or tabs at the start of the + /// next token's leading trivia. + lazy var combinedTrailingTrivia: Trivia = { + let nextTokenLeadingWhitespace = nextToken?.leadingTrivia.prefix(while: { $0.isSpaceOrTab }) ?? [] + return trailingTrivia + Trivia(pieces: nextTokenLeadingWhitespace) + }() + + var leadingTrivia = token.leadingTrivia + var trailingTrivia = token.trailingTrivia + + if requiresLeadingNewline(token) { + // Add a leading newline if the token requires it unless + // - it already starts with a newline or + // - the previous token ends with a newline + if !leadingTrivia.startsWithNewline && !previousTokenWillEndWithNewline { + // Add a leading newline if the token requires it and + // - it doesn't already start with a newline and + // - the previous token didn't end with a newline + leadingTrivia = .newline + leadingTrivia + } + } else if requiresWhitespace(between: previousToken, and: token) { + // Add a leading space if the token requires it unless + // - it already starts with a whitespace or + // - the previous token ends with a whitespace after the rewrite + if !leadingTrivia.startsWithWhitespace && !previousTokenWillEndWithWhitespace { + leadingTrivia += .space + } + } + + if leadingTrivia.indentation(isOnNewline: previousTokenWillEndWithNewline) == [] { + // If the token starts on a new line and does not have indentation, this + // is the last non-indented token. Store its indentation level + anchorPoints[token] = currentIndentationLevel + } + + // Add a trailing space to the token unless + // - it already ends with a whitespace or + // - the next token will start starts with a newline after the rewrite + // because newlines should be preferred to spaces as a whitespace + if requiresWhitespace(between: token, and: nextToken) + && !trailingTrivia.endsWithWhitespace + && !nextTokenWillStartWithNewline + { + trailingTrivia += .space + } + + var leadingTriviaIndentation = self.currentIndentationLevel + var trailingTriviaIndentation = self.currentIndentationLevel + + // If the trivia contain user-defined indentation, find their anchor point + // and indent the token relative to that anchor point. + if leadingTrivia.containsIndentation(isOnNewline: previousTokenWillEndWithNewline), + let anchorPointIndentation = self.anchorPointIndentation(for: token) + { + leadingTriviaIndentation = anchorPointIndentation + } + if combinedTrailingTrivia.containsIndentation(isOnNewline: previousTokenWillEndWithNewline), + let anchorPointIndentation = self.anchorPointIndentation(for: token) + { + trailingTriviaIndentation = anchorPointIndentation + } + + leadingTrivia = leadingTrivia.indented(indentation: leadingTriviaIndentation, isOnNewline: previousTokenIsStringLiteralEndingInNewline) + trailingTrivia = trailingTrivia.indented(indentation: trailingTriviaIndentation, isOnNewline: false) + + leadingTrivia = leadingTrivia.trimmingTrailingWhitespaceBeforeNewline(isBeforeNewline: false) + trailingTrivia = trailingTrivia.trimmingTrailingWhitespaceBeforeNewline(isBeforeNewline: nextTokenWillStartWithNewline) + + if leadingTrivia == token.leadingTrivia && trailingTrivia == token.trailingTrivia { + return token + } + + return token.detach().with(\.leadingTrivia, leadingTrivia).with(\.trailingTrivia, trailingTrivia) + } +} diff --git a/Sources/SwiftBasicFormat/CMakeLists.txt b/Sources/SwiftBasicFormat/CMakeLists.txt index 6fe22217caa..c83ff4e1db7 100644 --- a/Sources/SwiftBasicFormat/CMakeLists.txt +++ b/Sources/SwiftBasicFormat/CMakeLists.txt @@ -7,9 +7,10 @@ # See http://swift.org/CONTRIBUTORS.txt for Swift project authors add_swift_host_library(SwiftBasicFormat - generated/BasicFormat.swift + BasicFormat.swift + generated/BasicFormat+Extensions.swift SyntaxProtocol+Formatted.swift - Trivia+Indented.swift + Trivia+FormatExtensions.swift ) target_link_libraries(SwiftBasicFormat PUBLIC diff --git a/Sources/SwiftBasicFormat/Trivia+FormatExtensions.swift b/Sources/SwiftBasicFormat/Trivia+FormatExtensions.swift new file mode 100644 index 00000000000..2bd55763743 --- /dev/null +++ b/Sources/SwiftBasicFormat/Trivia+FormatExtensions.swift @@ -0,0 +1,113 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax + +extension Trivia { + /// Removes all whitespaces that is trailing before a newline trivia, + /// effectively making sure that lines don't end with a whitespace + func trimmingTrailingWhitespaceBeforeNewline(isBeforeNewline: Bool) -> Trivia { + // Iterate through the trivia in reverse. Every time we see a newline drop + // all whitespaces until we see a non-whitespace trivia piece. + var isBeforeNewline = isBeforeNewline + var trimmedReversedPieces: [TriviaPiece] = [] + for piece in pieces.reversed() { + if piece.isNewline { + isBeforeNewline = true + trimmedReversedPieces.append(piece) + continue + } + if isBeforeNewline && piece.isWhitespace { + continue + } + trimmedReversedPieces.append(piece) + isBeforeNewline = false + } + return Trivia(pieces: trimmedReversedPieces.reversed()) + } + + /// Returns `true` if this trivia contains indentation. + func containsIndentation(isOnNewline: Bool) -> Bool { + guard let indentaton = indentation(isOnNewline: isOnNewline) else { + return false + } + return !indentaton.isEmpty + } + + /// Returns the indentation of the last trivia piece in this trivia that is + /// not a whitespace. + func indentation(isOnNewline: Bool) -> Trivia? { + let lastNonWhitespaceTriviaPieceIndex = self.pieces.lastIndex(where: { !$0.isWhitespace }) ?? self.pieces.endIndex + let piecesBeforeLastNonWhitespace = self.pieces[.. + if let lastNewlineIndex = piecesBeforeLastNonWhitespace.lastIndex(where: { $0.isNewline }) { + indentation = piecesBeforeLastNonWhitespace[(lastNewlineIndex + 1)...] + } else if isOnNewline { + indentation = piecesBeforeLastNonWhitespace + } else { + return nil + } + return Trivia(pieces: indentation) + } + + /// Adds `indentation` after every newline in this trivia. + func indented(indentation: Trivia, isOnNewline: Bool) -> Trivia { + guard !isEmpty else { + if isOnNewline { + return indentation + } + return self + } + + var indentedPieces: [TriviaPiece] = [] + if isOnNewline { + indentedPieces.append(contentsOf: indentation) + } + + for piece in pieces { + indentedPieces.append(piece) + if piece.isNewline { + indentedPieces.append(contentsOf: indentation) + } + } + + return Trivia(pieces: indentedPieces) + } + + var startsWithNewline: Bool { + guard let first = self.first else { + return false + } + return first.isNewline + } + + var startsWithWhitespace: Bool { + guard let first = self.first else { + return false + } + return first.isWhitespace + } + + var endsWithNewline: Bool { + guard let last = self.pieces.last else { + return false + } + return last.isNewline + } + + var endsWithWhitespace: Bool { + guard let last = self.pieces.last else { + return false + } + return last.isWhitespace + } +} diff --git a/Sources/SwiftBasicFormat/Trivia+Indented.swift b/Sources/SwiftBasicFormat/Trivia+Indented.swift deleted file mode 100644 index e8aa22e49a3..00000000000 --- a/Sources/SwiftBasicFormat/Trivia+Indented.swift +++ /dev/null @@ -1,48 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -import SwiftSyntax - -extension Trivia { - /// Makes sure each newline of this trivia is followed by `indentation`. If this is not the case, the existing indentation is extended to `indentation`. - /// `isOnNewline` determines whether the trivia starts on a new line. If this is the case, the function makes sure that the returned trivia starts with `indentation`. - func indented(indentation: TriviaPiece, isOnNewline: Bool = false) -> Trivia { - var indentedPieces: [TriviaPiece] = [] - for (index, piece) in self.enumerated() { - let previousPieceIsNewline: Bool - if index == 0 { - previousPieceIsNewline = isOnNewline - } else { - previousPieceIsNewline = pieces[index - 1].isNewline - } - if previousPieceIsNewline { - switch (piece, indentation) { - case (.spaces(let nextPieceSpaces), .spaces(let indentationSpaces)): - if nextPieceSpaces < indentationSpaces { - indentedPieces.append(.spaces(indentationSpaces - nextPieceSpaces)) - } - case (.tabs(let nextPieceTabs), .tabs(let indentationTabs)): - if nextPieceTabs < indentationTabs { - indentedPieces.append(.tabs(indentationTabs - nextPieceTabs)) - } - default: - indentedPieces.append(indentation) - } - } - indentedPieces.append(piece) - } - if self.pieces.last?.isNewline == true { - indentedPieces.append(indentation) - } - return Trivia(pieces: indentedPieces) - } -} diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat+Extensions.swift b/Sources/SwiftBasicFormat/generated/BasicFormat+Extensions.swift new file mode 100644 index 00000000000..2e07341afc0 --- /dev/null +++ b/Sources/SwiftBasicFormat/generated/BasicFormat+Extensions.swift @@ -0,0 +1,151 @@ +//// Automatically generated by generate-swiftsyntax +//// Do not edit directly! +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftSyntax + +public extension SyntaxProtocol { + var requiresIndent: Bool { + guard let keyPath = keyPathInParent else { + return false + } + return keyPath.requiresIndent + } +} + +public extension TokenSyntax { + var requiresLeadingNewline: Bool { + if let keyPath = keyPathInParent, keyPath.requiresLeadingNewline { + return true + } + return false + } +} + +fileprivate extension AnyKeyPath { + var requiresIndent: Bool { + switch self { + case \AccessorBlockSyntax.accessors: + return true + case \ArrayExprSyntax.elements: + return true + case \ClosureExprSyntax.statements: + return true + case \ClosureParameterClauseSyntax.parameterList: + return true + case \CodeBlockSyntax.statements: + return true + case \DictionaryElementSyntax.valueExpression: + return true + case \DictionaryExprSyntax.content: + return true + case \EnumCaseParameterClauseSyntax.parameterList: + return true + case \FunctionCallExprSyntax.argumentList: + return true + case \FunctionTypeSyntax.arguments: + return true + case \MemberDeclBlockSyntax.members: + return true + case \ParameterClauseSyntax.parameterList: + return true + case \SwitchCaseSyntax.statements: + return true + case \TupleExprSyntax.elementList: + return true + case \TupleTypeSyntax.elements: + return true + default: + return false + } + } + + var requiresLeadingNewline: Bool { + switch self { + case \AccessorBlockSyntax.rightBrace: + return true + case \ClosureExprSyntax.rightBrace: + return true + case \CodeBlockSyntax.rightBrace: + return true + case \IfConfigClauseSyntax.poundKeyword: + return true + case \IfConfigDeclSyntax.poundEndif: + return true + case \MemberDeclBlockSyntax.rightBrace: + return true + case \SwitchExprSyntax.rightBrace: + return true + default: + return false + } + } + + var requiresLeadingSpace: Bool? { + switch self { + case \AvailabilityArgumentSyntax.entry: + return false + case \FunctionParameterSyntax.secondName: + return true + case \MissingDeclSyntax.placeholder: + return false + case \MissingExprSyntax.placeholder: + return false + case \MissingPatternSyntax.placeholder: + return false + case \MissingStmtSyntax.placeholder: + return false + case \MissingSyntax.placeholder: + return false + case \MissingTypeSyntax.placeholder: + return false + default: + return nil + } + } + + var requiresTrailingSpace: Bool? { + switch self { + case \AvailabilityArgumentSyntax.entry: + return false + case \BreakStmtSyntax.breakKeyword: + return false + case \DeclNameArgumentSyntax.colon: + return false + case \DictionaryExprSyntax.content: + return false + case \DynamicReplacementArgumentsSyntax.forLabel: + return false + case \MissingDeclSyntax.placeholder: + return false + case \MissingExprSyntax.placeholder: + return false + case \MissingPatternSyntax.placeholder: + return false + case \MissingStmtSyntax.placeholder: + return false + case \MissingSyntax.placeholder: + return false + case \MissingTypeSyntax.placeholder: + return false + case \SwitchCaseLabelSyntax.colon: + return false + case \SwitchDefaultLabelSyntax.colon: + return false + case \TryExprSyntax.questionOrExclamationMark: + return true + default: + return nil + } + } +} diff --git a/Sources/SwiftBasicFormat/generated/BasicFormat.swift b/Sources/SwiftBasicFormat/generated/BasicFormat.swift deleted file mode 100644 index 44a5ad660da..00000000000 --- a/Sources/SwiftBasicFormat/generated/BasicFormat.swift +++ /dev/null @@ -1,372 +0,0 @@ -//// Automatically generated by generate-swiftsyntax -//// Do not edit directly! -//===----------------------------------------------------------------------===// -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See https://swift.org/LICENSE.txt for license information -// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -// -//===----------------------------------------------------------------------===// - -import SwiftSyntax - -open class BasicFormat: SyntaxRewriter { - public var indentationLevel: Int = 0 - - open var indentation: TriviaPiece { - .spaces(indentationLevel * 4) - } - - public var indentedNewline: Trivia { - Trivia(pieces: [.newlines(1), indentation]) - } - - private var lastRewrittenToken: TokenSyntax? - - private var putNextTokenOnNewLine: Bool = false - - open override func visitPre(_ node: Syntax) { - if let keyPath = node.keyPathInParent, shouldIndent(keyPath) { - indentationLevel += 1 - } - if let parent = node.parent, childrenSeparatedByNewline(parent) { - putNextTokenOnNewLine = true && node.previousToken(viewMode: .sourceAccurate) != nil - } - } - - open override func visitPost(_ node: Syntax) { - if let keyPath = node.keyPathInParent, shouldIndent(keyPath) { - indentationLevel -= 1 - } - } - - open override func visit(_ node: TokenSyntax) -> TokenSyntax { - var leadingTrivia = node.leadingTrivia - var trailingTrivia = node.trailingTrivia - if requiresLeadingSpace(node) && leadingTrivia.isEmpty && lastRewrittenToken?.trailingTrivia.isEmpty != false { - leadingTrivia += .space - } - if requiresTrailingSpace(node) && trailingTrivia.isEmpty { - trailingTrivia += .space - } - if let keyPath = node.keyPathInParent, requiresLeadingNewline(keyPath), !(leadingTrivia.first?.isNewline ?? false), !shouldOmitNewline(node) { - leadingTrivia = .newline + leadingTrivia - } - var isOnNewline: Bool = (lastRewrittenToken?.trailingTrivia.pieces.last?.isNewline == true) - if case .stringSegment(let text) = lastRewrittenToken?.tokenKind { - isOnNewline = isOnNewline || (text.last?.isNewline == true) - } - leadingTrivia = leadingTrivia.indented(indentation: indentation, isOnNewline: isOnNewline) - let rewritten = TokenSyntax( - node.tokenKind, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: node.presence - - ) - lastRewrittenToken = rewritten - putNextTokenOnNewLine = false - return rewritten - } - - /// If this returns `true`, ``BasicFormat`` will not wrap `node` to a new line. This can be used to e.g. keep string interpolation segments on a single line. - /// - Parameter node: the node that is being visited - /// - Returns: returns true if newline should be omitted - open func shouldOmitNewline(_ node: TokenSyntax) -> Bool { - if node.previousToken(viewMode: .sourceAccurate) == nil { - return true - } - var ancestor: Syntax = Syntax(node) - while let parent = ancestor.parent { - ancestor = parent - if ancestor.is(ExpressionSegmentSyntax.self) { - return true - } - } - - return false - } - - open func shouldIndent(_ keyPath: AnyKeyPath) -> Bool { - switch keyPath { - case \AccessorBlockSyntax.accessors: - return true - case \ArrayExprSyntax.elements: - return true - case \ClosureExprSyntax.statements: - return true - case \ClosureParameterClauseSyntax.parameterList: - return true - case \CodeBlockSyntax.statements: - return true - case \DictionaryElementSyntax.valueExpression: - return true - case \DictionaryExprSyntax.content: - return true - case \EnumCaseParameterClauseSyntax.parameterList: - return true - case \FunctionCallExprSyntax.argumentList: - return true - case \FunctionTypeSyntax.arguments: - return true - case \MemberDeclBlockSyntax.members: - return true - case \ParameterClauseSyntax.parameterList: - return true - case \SwitchCaseSyntax.statements: - return true - case \TupleExprSyntax.elementList: - return true - case \TupleTypeSyntax.elements: - return true - default: - return false - } - } - - open func requiresLeadingNewline(_ keyPath: AnyKeyPath) -> Bool { - switch keyPath { - case \AccessorBlockSyntax.rightBrace: - return true - case \ClosureExprSyntax.rightBrace: - return true - case \CodeBlockSyntax.rightBrace: - return true - case \IfConfigClauseSyntax.poundKeyword: - return true - case \IfConfigDeclSyntax.poundEndif: - return true - case \MemberDeclBlockSyntax.rightBrace: - return true - case \SwitchExprSyntax.rightBrace: - return true - default: - return putNextTokenOnNewLine - } - } - - open func childrenSeparatedByNewline(_ node: Syntax) -> Bool { - switch node.as(SyntaxEnum.self) { - case .accessorList: - return true - case .codeBlockItemList: - return true - case .memberDeclList: - return true - case .switchCaseList: - return true - default: - return false - } - } - - /// If this returns a value that is not `nil`, it overrides the default - /// leading space behavior of a token. - open func requiresLeadingSpace(_ keyPath: AnyKeyPath) -> Bool? { - switch keyPath { - case \AvailabilityArgumentSyntax.entry: - return false - case \FunctionParameterSyntax.secondName: - return true - default: - return nil - } - } - - open func requiresLeadingSpace(_ token: TokenSyntax) -> Bool { - if let keyPath = token.keyPathInParent, let requiresLeadingSpace = requiresLeadingSpace(keyPath) { - return requiresLeadingSpace - } - switch (token.previousToken(viewMode: .sourceAccurate)?.tokenKind, token.tokenKind) { - case (.leftParen, .leftBrace): // Ensures there is not a space in `.map({ $0.foo })` - return false - default: - break - } - switch token.tokenKind { - case .arrow: - return true - case .binaryOperator: - return true - case .equal: - return true - case .leftBrace: - return true - case .keyword(.`catch`): - return true - case .keyword(.`else`): - return true - case .keyword(.`in`): - return true - case .keyword(.`where`): - return true - default: - return false - } - } - - /// If this returns a value that is not `nil`, it overrides the default - /// trailing space behavior of a token. - open func requiresTrailingSpace(_ keyPath: AnyKeyPath) -> Bool? { - switch keyPath { - case \AvailabilityArgumentSyntax.entry: - return false - case \BreakStmtSyntax.breakKeyword: - return false - case \DeclNameArgumentSyntax.colon: - return false - case \DictionaryExprSyntax.content: - return false - case \DynamicReplacementArgumentsSyntax.forLabel: - return false - case \SwitchCaseLabelSyntax.colon: - return false - case \SwitchDefaultLabelSyntax.colon: - return false - case \TryExprSyntax.questionOrExclamationMark: - return true - default: - return nil - } - } - - open func requiresTrailingSpace(_ token: TokenSyntax) -> Bool { - if let keyPath = token.keyPathInParent, let requiresTrailingSpace = requiresTrailingSpace(keyPath) { - return requiresTrailingSpace - } - switch (token.tokenKind, token.nextToken(viewMode: .sourceAccurate)?.tokenKind) { - case (.exclamationMark, .leftParen), // Ensures there is not a space in `myOptionalClosure!()` - (.exclamationMark, .period), // Ensures there is not a space in `myOptionalBar!.foo()` - (.keyword(.as), .exclamationMark), // Ensures there is not a space in `as!` - (.keyword(.as), .postfixQuestionMark), // Ensures there is not a space in `as?` - (.keyword(.try), .exclamationMark), // Ensures there is not a space in `try!` - (.keyword(.try), .postfixQuestionMark), // Ensures there is not a space in `try?`: - (.postfixQuestionMark, .leftParen), // Ensures there is not a space in `init?()` or `myOptionalClosure?()`s - (.postfixQuestionMark, .rightAngle), // Ensures there is not a space in `ContiguousArray` - (.postfixQuestionMark, .rightParen): // Ensures there is not a space in `myOptionalClosure?()` - return false - default: - break - } - switch token.tokenKind { - case .arrow: - return true - case .binaryOperator: - return true - case .colon: - return true - case .comma: - return true - case .equal: - return true - case .poundAvailableKeyword: - return true - case .poundElseKeyword: - return true - case .poundElseifKeyword: - return true - case .poundEndifKeyword: - return true - case .poundIfKeyword: - return true - case .poundSourceLocationKeyword: - return true - case .poundUnavailableKeyword: - return true - case .keyword(.`Any`): - return true - case .keyword(.`as`): - return true - case .keyword(.`associatedtype`): - return true - case .keyword(.async): - return true - case .keyword(.await): - return true - case .keyword(.`break`): - return true - case .keyword(.`case`): - return true - case .keyword(.`class`): - return true - case .keyword(.`continue`): - return true - case .keyword(.`defer`): - return true - case .keyword(.`else`): - return true - case .keyword(.`enum`): - return true - case .keyword(.`extension`): - return true - case .keyword(.`fallthrough`): - return true - case .keyword(.`fileprivate`): - return true - case .keyword(.`for`): - return true - case .keyword(.`func`): - return true - case .keyword(.`guard`): - return true - case .keyword(.`if`): - return true - case .keyword(.`import`): - return true - case .keyword(.`in`): - return true - case .keyword(.`inout`): - return true - case .keyword(.`internal`): - return true - case .keyword(.`is`): - return true - case .keyword(.`let`): - return true - case .keyword(.`operator`): - return true - case .keyword(.`precedencegroup`): - return true - case .keyword(.`private`): - return true - case .keyword(.`protocol`): - return true - case .keyword(.`public`): - return true - case .keyword(.`repeat`): - return true - case .keyword(.`rethrows`): - return true - case .keyword(.`return`): - return true - case .keyword(.`static`): - return true - case .keyword(.`struct`): - return true - case .keyword(.`subscript`): - return true - case .keyword(.`switch`): - return true - case .keyword(.`throw`): - return true - case .keyword(.`throws`): - return true - case .keyword(.`try`): - return true - case .keyword(.`typealias`): - return true - case .keyword(.`var`): - return true - case .keyword(.`where`): - return true - case .keyword(.`while`): - return true - default: - return false - } - } -} diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift index d2fe86f973e..0d736f9e873 100644 --- a/Sources/SwiftParser/Declarations.swift +++ b/Sources/SwiftParser/Declarations.swift @@ -465,7 +465,7 @@ extension Parser { } precondition(self.currentToken.starts(with: "<")) - let langle = self.consumeAnyToken(remapping: .leftAngle) + let langle = self.consumePrefix("<", as: .leftAngle) var elements = [RawGenericParameterSyntax]() do { var keepGoing: RawTokenSyntax? = nil @@ -477,7 +477,7 @@ extension Parser { var each = self.consume(if: .keyword(.each)) let (unexpectedBetweenEachAndName, name) = self.expectIdentifier(allowSelfOrCapitalSelfAsIdentifier: true) - if attributes == nil && each == nil && unexpectedBetweenEachAndName == nil && name.isMissing && elements.isEmpty { + if attributes == nil && each == nil && unexpectedBetweenEachAndName == nil && name.isMissing && elements.isEmpty && !self.currentToken.starts(with: ">") { break } diff --git a/Sources/SwiftParser/generated/IsLexerClassified.swift b/Sources/SwiftParser/generated/IsLexerClassified.swift index caf7c25a11c..1e7ad709a71 100644 --- a/Sources/SwiftParser/generated/IsLexerClassified.swift +++ b/Sources/SwiftParser/generated/IsLexerClassified.swift @@ -19,113 +19,113 @@ extension Keyword { /// This is true for keywords that used to be considered non-contextual. var isLexerClassified: Bool { switch self { - case .`Any`: + case .`Any`: return true - case .`as`: + case .`as`: return true - case .`associatedtype`: + case .`associatedtype`: return true - case .`break`: + case .`break`: return true - case .`case`: + case .`case`: return true - case .`catch`: + case .`catch`: return true - case .`class`: + case .`class`: return true - case .`continue`: + case .`continue`: return true - case .`default`: + case .`default`: return true - case .`defer`: + case .`defer`: return true - case .`deinit`: + case .`deinit`: return true - case .`do`: + case .`do`: return true - case .`else`: + case .`else`: return true - case .`enum`: + case .`enum`: return true - case .`extension`: + case .`extension`: return true - case .`fallthrough`: + case .`fallthrough`: return true - case .`false`: + case .`false`: return true - case .`fileprivate`: + case .`fileprivate`: return true - case .`for`: + case .`for`: return true - case .`func`: + case .`func`: return true - case .`guard`: + case .`guard`: return true - case .`if`: + case .`if`: return true - case .`import`: + case .`import`: return true - case .`in`: + case .`in`: return true - case .`init`: + case .`init`: return true - case .`inout`: + case .`inout`: return true - case .`internal`: + case .`internal`: return true - case .`is`: + case .`is`: return true - case .`let`: + case .`let`: return true - case .`nil`: + case .`nil`: return true - case .`operator`: + case .`operator`: return true - case .`precedencegroup`: + case .`precedencegroup`: return true - case .`private`: + case .`private`: return true - case .`protocol`: + case .`protocol`: return true - case .`public`: + case .`public`: return true - case .`repeat`: + case .`repeat`: return true - case .`rethrows`: + case .`rethrows`: return true - case .`return`: + case .`return`: return true - case .`self`: + case .`self`: return true - case .`Self`: + case .`Self`: return true - case .`static`: + case .`static`: return true - case .`struct`: + case .`struct`: return true - case .`subscript`: + case .`subscript`: return true - case .`super`: + case .`super`: return true - case .`switch`: + case .`switch`: return true - case .`throw`: + case .`throw`: return true - case .`throws`: + case .`throws`: return true - case .`true`: + case .`true`: return true - case .`try`: + case .`try`: return true - case .`typealias`: + case .`typealias`: return true - case .`var`: + case .`var`: return true - case .`where`: + case .`where`: return true - case .`while`: + case .`while`: return true - default: + default: return false } } @@ -157,7 +157,7 @@ extension TokenKind { return true case .keyword(let keyword): return keyword.isLexerClassified - default: + default: return false } } diff --git a/Sources/SwiftParser/generated/Parser+Entry.swift b/Sources/SwiftParser/generated/Parser+Entry.swift index fae2fdabc5a..f6a9a97561c 100644 --- a/Sources/SwiftParser/generated/Parser+Entry.swift +++ b/Sources/SwiftParser/generated/Parser+Entry.swift @@ -18,7 +18,7 @@ extension Parser { /// Parse the source code in the given string as Swift source file. See /// `Parser.init` for more details. public static func parse( - source: String, + source: String, parseTransition: IncrementalParseTransition? = nil ) -> SourceFileSyntax { var parser = Parser(source) @@ -28,8 +28,8 @@ extension Parser { /// Parse the source code in the given string as Swift source file. See /// `Parser.init` for more details. public static func parse( - source: UnsafeBufferPointer, - maximumNestingLevel: Int? = nil, + source: UnsafeBufferPointer, + maximumNestingLevel: Int? = nil, parseTransition: IncrementalParseTransition? = nil ) -> SourceFileSyntax { var parser = Parser(source, maximumNestingLevel: maximumNestingLevel) diff --git a/Sources/SwiftParser/generated/TokenSpecStaticMembers.swift b/Sources/SwiftParser/generated/TokenSpecStaticMembers.swift index 9321eef4b86..6836b39a3b2 100644 --- a/Sources/SwiftParser/generated/TokenSpecStaticMembers.swift +++ b/Sources/SwiftParser/generated/TokenSpecStaticMembers.swift @@ -15,199 +15,199 @@ @_spi(RawSyntax) import SwiftSyntax extension TokenSpec { - static var eof: TokenSpec { - return TokenSpec(.eof) + static var eof: TokenSpec { + return TokenSpec(.eof) } - static var arrow: TokenSpec { - return TokenSpec(.arrow) + static var arrow: TokenSpec { + return TokenSpec(.arrow) } - static var atSign: TokenSpec { - return TokenSpec(.atSign) + static var atSign: TokenSpec { + return TokenSpec(.atSign) } - static var backslash: TokenSpec { - return TokenSpec(.backslash) + static var backslash: TokenSpec { + return TokenSpec(.backslash) } - static var backtick: TokenSpec { - return TokenSpec(.backtick) + static var backtick: TokenSpec { + return TokenSpec(.backtick) } - static var binaryOperator: TokenSpec { - return TokenSpec(.binaryOperator) + static var binaryOperator: TokenSpec { + return TokenSpec(.binaryOperator) } - static var colon: TokenSpec { - return TokenSpec(.colon) + static var colon: TokenSpec { + return TokenSpec(.colon) } - static var comma: TokenSpec { - return TokenSpec(.comma) + static var comma: TokenSpec { + return TokenSpec(.comma) } - static var dollarIdentifier: TokenSpec { - return TokenSpec(.dollarIdentifier) + static var dollarIdentifier: TokenSpec { + return TokenSpec(.dollarIdentifier) } - static var ellipsis: TokenSpec { - return TokenSpec(.ellipsis) + static var ellipsis: TokenSpec { + return TokenSpec(.ellipsis) } - static var equal: TokenSpec { - return TokenSpec(.equal) + static var equal: TokenSpec { + return TokenSpec(.equal) } - static var exclamationMark: TokenSpec { - return TokenSpec(.exclamationMark) + static var exclamationMark: TokenSpec { + return TokenSpec(.exclamationMark) } - static var extendedRegexDelimiter: TokenSpec { - return TokenSpec(.extendedRegexDelimiter) + static var extendedRegexDelimiter: TokenSpec { + return TokenSpec(.extendedRegexDelimiter) } - static var floatingLiteral: TokenSpec { - return TokenSpec(.floatingLiteral) + static var floatingLiteral: TokenSpec { + return TokenSpec(.floatingLiteral) } - static var identifier: TokenSpec { - return TokenSpec(.identifier) + static var identifier: TokenSpec { + return TokenSpec(.identifier) } - static var infixQuestionMark: TokenSpec { - return TokenSpec(.infixQuestionMark) + static var infixQuestionMark: TokenSpec { + return TokenSpec(.infixQuestionMark) } - static var integerLiteral: TokenSpec { - return TokenSpec(.integerLiteral) + static var integerLiteral: TokenSpec { + return TokenSpec(.integerLiteral) } - static var leftAngle: TokenSpec { - return TokenSpec(.leftAngle) + static var leftAngle: TokenSpec { + return TokenSpec(.leftAngle) } - static var leftBrace: TokenSpec { - return TokenSpec(.leftBrace) + static var leftBrace: TokenSpec { + return TokenSpec(.leftBrace) } - static var leftParen: TokenSpec { - return TokenSpec(.leftParen) + static var leftParen: TokenSpec { + return TokenSpec(.leftParen) } - static var leftSquareBracket: TokenSpec { - return TokenSpec(.leftSquareBracket) + static var leftSquareBracket: TokenSpec { + return TokenSpec(.leftSquareBracket) } - static var multilineStringQuote: TokenSpec { - return TokenSpec(.multilineStringQuote) + static var multilineStringQuote: TokenSpec { + return TokenSpec(.multilineStringQuote) } - static var period: TokenSpec { - return TokenSpec(.period) + static var period: TokenSpec { + return TokenSpec(.period) } - static var postfixOperator: TokenSpec { - return TokenSpec(.postfixOperator) + static var postfixOperator: TokenSpec { + return TokenSpec(.postfixOperator) } - static var postfixQuestionMark: TokenSpec { - return TokenSpec(.postfixQuestionMark) + static var postfixQuestionMark: TokenSpec { + return TokenSpec(.postfixQuestionMark) } - static var pound: TokenSpec { - return TokenSpec(.pound) + static var pound: TokenSpec { + return TokenSpec(.pound) } - static var poundAvailableKeyword: TokenSpec { - return TokenSpec(.poundAvailableKeyword) + static var poundAvailableKeyword: TokenSpec { + return TokenSpec(.poundAvailableKeyword) } - static var poundElseKeyword: TokenSpec { - return TokenSpec(.poundElseKeyword) + static var poundElseKeyword: TokenSpec { + return TokenSpec(.poundElseKeyword) } - static var poundElseifKeyword: TokenSpec { - return TokenSpec(.poundElseifKeyword) + static var poundElseifKeyword: TokenSpec { + return TokenSpec(.poundElseifKeyword) } - static var poundEndifKeyword: TokenSpec { - return TokenSpec(.poundEndifKeyword) + static var poundEndifKeyword: TokenSpec { + return TokenSpec(.poundEndifKeyword) } - static var poundIfKeyword: TokenSpec { - return TokenSpec(.poundIfKeyword) + static var poundIfKeyword: TokenSpec { + return TokenSpec(.poundIfKeyword) } - static var poundSourceLocationKeyword: TokenSpec { - return TokenSpec(.poundSourceLocationKeyword) + static var poundSourceLocationKeyword: TokenSpec { + return TokenSpec(.poundSourceLocationKeyword) } - static var poundUnavailableKeyword: TokenSpec { - return TokenSpec(.poundUnavailableKeyword) + static var poundUnavailableKeyword: TokenSpec { + return TokenSpec(.poundUnavailableKeyword) } - static var prefixAmpersand: TokenSpec { - return TokenSpec(.prefixAmpersand) + static var prefixAmpersand: TokenSpec { + return TokenSpec(.prefixAmpersand) } - static var prefixOperator: TokenSpec { - return TokenSpec(.prefixOperator) + static var prefixOperator: TokenSpec { + return TokenSpec(.prefixOperator) } - static var rawStringDelimiter: TokenSpec { - return TokenSpec(.rawStringDelimiter) + static var rawStringDelimiter: TokenSpec { + return TokenSpec(.rawStringDelimiter) } - static var regexLiteralPattern: TokenSpec { - return TokenSpec(.regexLiteralPattern) + static var regexLiteralPattern: TokenSpec { + return TokenSpec(.regexLiteralPattern) } - static var regexSlash: TokenSpec { - return TokenSpec(.regexSlash) + static var regexSlash: TokenSpec { + return TokenSpec(.regexSlash) } - static var rightAngle: TokenSpec { - return TokenSpec(.rightAngle) + static var rightAngle: TokenSpec { + return TokenSpec(.rightAngle) } - static var rightBrace: TokenSpec { - return TokenSpec(.rightBrace) + static var rightBrace: TokenSpec { + return TokenSpec(.rightBrace) } - static var rightParen: TokenSpec { - return TokenSpec(.rightParen) + static var rightParen: TokenSpec { + return TokenSpec(.rightParen) } - static var rightSquareBracket: TokenSpec { - return TokenSpec(.rightSquareBracket) + static var rightSquareBracket: TokenSpec { + return TokenSpec(.rightSquareBracket) } - static var semicolon: TokenSpec { - return TokenSpec(.semicolon) + static var semicolon: TokenSpec { + return TokenSpec(.semicolon) } - static var singleQuote: TokenSpec { - return TokenSpec(.singleQuote) + static var singleQuote: TokenSpec { + return TokenSpec(.singleQuote) } - static var stringQuote: TokenSpec { - return TokenSpec(.stringQuote) + static var stringQuote: TokenSpec { + return TokenSpec(.stringQuote) } - static var stringSegment: TokenSpec { - return TokenSpec(.stringSegment) + static var stringSegment: TokenSpec { + return TokenSpec(.stringSegment) } - static var unknown: TokenSpec { - return TokenSpec(.unknown) + static var unknown: TokenSpec { + return TokenSpec(.unknown) } - static var wildcard: TokenSpec { - return TokenSpec(.wildcard) + static var wildcard: TokenSpec { + return TokenSpec(.wildcard) } - static func keyword(_ keyword: Keyword) -> TokenSpec { - return TokenSpec(keyword) + static func keyword(_ keyword: Keyword) -> TokenSpec { + return TokenSpec(keyword) } } diff --git a/Sources/SwiftParserDiagnostics/DiagnosticExtensions.swift b/Sources/SwiftParserDiagnostics/DiagnosticExtensions.swift index f428cfc9da4..9ce0838f598 100644 --- a/Sources/SwiftParserDiagnostics/DiagnosticExtensions.swift +++ b/Sources/SwiftParserDiagnostics/DiagnosticExtensions.swift @@ -59,6 +59,8 @@ extension FixIt { } } +// MARK: - Make missing + extension FixIt.MultiNodeChange { /// Replaced a present token with a missing node. /// If `transferTrivia` is `true`, the leading and trailing trivia of the @@ -98,6 +100,37 @@ extension FixIt.MultiNodeChange { return FixIt.MultiNodeChange(primitiveChanges: changes) } + /// Transfers the leading and trailing trivia of `nodes` to the previous token + /// While doing this, it tries to be smart, merging trivia where it makes sense + /// and refusing to add e.g. a space after punctuation, where it usually + /// doesn't make sense. + private static func transferTriviaAtSides(from nodes: [SyntaxType]) -> Self { + let removedTriviaAtSides = (nodes.first?.leadingTrivia ?? []).merging(nodes.last?.trailingTrivia ?? []) + if !removedTriviaAtSides.isEmpty, let previousToken = nodes.first?.previousToken(viewMode: .sourceAccurate) { + let mergedTrivia = previousToken.trailingTrivia.merging(removedTriviaAtSides) + if previousToken.tokenKind.isPunctuation, mergedTrivia.allSatisfy({ $0.isSpaceOrTab }) { + // Punctuation is generally not followed by spaces in Swift. + // If this action would only add spaces to the punctuation, drop it. + // This generally yields better results. + return FixIt.MultiNodeChange() + } + return FixIt.MultiNodeChange(.replaceTrailingTrivia(token: previousToken, newTrivia: mergedTrivia)) + } else { + return FixIt.MultiNodeChange() + } + } +} + +// MARK: - Make present + +class MissingNodesBasicFormatter: BasicFormat { + override func isMutable(_ token: TokenSyntax) -> Bool { + // Assume that all missing nodes will be made present by the Fix-It. + return token.presence == .missing + } +} + +extension FixIt.MultiNodeChange { /// Make a node present. If `leadingTrivia` or `trailingTrivia` is specified, /// override the default leading/trailing trivia inferred from `BasicFormat`. static func makePresent( @@ -105,93 +138,53 @@ extension FixIt.MultiNodeChange { leadingTrivia: Trivia? = nil, trailingTrivia: Trivia? = nil ) -> Self { - var presentNode = PresentMaker().visit(Syntax(node)) + var presentNode = MissingNodesBasicFormatter(viewMode: .fixedUp).visit(Syntax(node)) + presentNode = PresentMaker().rewrite(presentNode) + if let leadingTrivia = leadingTrivia { presentNode = presentNode.with(\.leadingTrivia, leadingTrivia) } if let trailingTrivia = trailingTrivia { presentNode = presentNode.with(\.trailingTrivia, trailingTrivia) } + + var changes: [FixIt.Change] = [] + if node.shouldBeInsertedAfterNextTokenTrivia, let nextToken = node.nextToken(viewMode: .sourceAccurate), leadingTrivia == nil { - return FixIt.MultiNodeChange( - .replace( - oldNode: Syntax(node), - newNode: Syntax(presentNode).with(\.leadingTrivia, nextToken.leadingTrivia) - ), - .replaceLeadingTrivia(token: nextToken, newTrivia: []) - ) - } else if node.leadingTrivia.isEmpty, - let previousToken = node.previousToken(viewMode: .fixedUp), - previousToken.presence == .present, - previousToken.trailingTrivia.isEmpty, - BasicFormat().requiresTrailingSpace(previousToken), - leadingTrivia == nil - { - /// If neither this nor the previous token are punctionation make sure they - /// are separated by a space. - return FixIt.MultiNodeChange( - .replace( - oldNode: Syntax(node), - newNode: Syntax(presentNode).with(\.leadingTrivia, .space) - ) - ) - } else { - return FixIt.MultiNodeChange( - .replace( - oldNode: Syntax(node), - newNode: Syntax(presentNode) - ) - ) - } - } + // Move the next token's leading trivia to this node's leading trivia. + changes.append(.replaceLeadingTrivia(token: nextToken, newTrivia: [])) + presentNode = presentNode.with(\.leadingTrivia, nextToken.leadingTrivia) - /// Makes the `token` present, moving it in front of the previous token's trivia. - static func makePresentBeforeTrivia(_ token: TokenSyntax) -> Self { - if let previousToken = token.previousToken(viewMode: .sourceAccurate) { - var presentToken = PresentMaker().visit(token) - if !previousToken.trailingTrivia.isEmpty { - presentToken = presentToken.with(\.trailingTrivia, previousToken.trailingTrivia) + // If this node and the next token need to be separated, insert a space. + if let lastToken = node.lastToken(viewMode: .all), + lastToken.trailingTrivia.isEmpty, + BasicFormat().requiresWhitespace(between: lastToken, and: nextToken) + { + presentNode = presentNode.with(\.trailingTrivia, .space) } - return FixIt.MultiNodeChange( - .replaceTrailingTrivia(token: previousToken, newTrivia: []), - .replace(oldNode: Syntax(token), newNode: Syntax(presentToken)) - ) - } else { - return .makePresent(token) } - } - /// Transfers the leading and trivia trivia of `nodes` to the trailing trivia - /// of the previous token. While doing this, it tries to be smart, merging trivia - /// where it makes sense and refusing to add e.g. a space after punctuation, - /// where it usually doesn't make sense. - static func transferTriviaAtSides(from nodes: [SyntaxType]) -> Self { - let removedTriviaAtSides = (nodes.first?.leadingTrivia ?? []).merging(nodes.last?.trailingTrivia ?? []) - if !removedTriviaAtSides.isEmpty, let previousToken = nodes.first?.previousToken(viewMode: .sourceAccurate) { - let mergedTrivia = previousToken.trailingTrivia.merging(removedTriviaAtSides) - if previousToken.tokenKind.isPunctuation, mergedTrivia.allSatisfy({ $0.isSpaceOrTab }) { - // Punctuation is generally not followed by spaces in Swift. - // If this action would only add spaces to the punctuation, drop it. - // This generally yields better results. - return FixIt.MultiNodeChange() - } - return FixIt.MultiNodeChange(.replaceTrailingTrivia(token: previousToken, newTrivia: mergedTrivia)) - } else { - return FixIt.MultiNodeChange() + if let previousToken = node.previousToken(viewMode: .all), + previousToken.presence == .present, + let firstToken = node.firstToken(viewMode: .all), + previousToken.trailingTrivia.allSatisfy({ $0.isWhitespace }), + !BasicFormat().requiresWhitespace(between: previousToken, and: firstToken) + { + // If the previous token and this node don't need to be separated, remove + // the separation. + changes.append(.replaceTrailingTrivia(token: previousToken, newTrivia: [])) } - } -} -extension TriviaPiece { - var isSpaceOrTab: Bool { - switch self { - case .spaces, .tabs: - return true - default: - return false - } + changes.append( + .replace( + oldNode: Syntax(node), + newNode: Syntax(presentNode) + ) + ) + + return FixIt.MultiNodeChange(primitiveChanges: changes) } } diff --git a/Sources/SwiftParserDiagnostics/MissingNodesError.swift b/Sources/SwiftParserDiagnostics/MissingNodesError.swift index bf562748ac3..29137d69fde 100644 --- a/Sources/SwiftParserDiagnostics/MissingNodesError.swift +++ b/Sources/SwiftParserDiagnostics/MissingNodesError.swift @@ -21,6 +21,12 @@ fileprivate func findCommonAncestor(_ nodes: [Syntax]) -> Syntax? { return findCommonAncestorOrSelf(nodes.compactMap({ $0.parent })) } +class NoNewlinesFormat: BasicFormat { + override func requiresLeadingNewline(_ token: TokenSyntax) -> Bool { + return false + } +} + fileprivate enum NodesDescriptionPart { case tokensWithDefaultText([TokenSyntax]) case tokenWithoutDefaultText(TokenSyntax) @@ -30,7 +36,7 @@ fileprivate enum NodesDescriptionPart { switch self { case .tokensWithDefaultText(var tokens): if format { - tokens = tokens.map({ BasicFormat().visit($0) }) + tokens = tokens.map({ NoNewlinesFormat(viewMode: .all).visit($0) }) } if !tokens.isEmpty { tokens[0] = tokens[0].with(\.leadingTrivia, []) @@ -70,11 +76,11 @@ fileprivate enum NodesDescriptionPart { } else { let (rawKind, text) = token.tokenKind.decomposeToRaw() if let text = text, !text.isEmpty { - let presentToken = TokenSyntax(token.tokenKind, presence: .present) + let presentToken = token.with(\.presence, .present) newPart = .tokensWithDefaultText([presentToken]) } else if let defaultText = rawKind.defaultText { let newKind = TokenKind.fromRaw(kind: rawKind, text: String(syntaxText: defaultText)) - let presentToken = TokenSyntax(newKind, presence: .present) + let presentToken = token.with(\.tokenKind, newKind).with(\.presence, .present) newPart = .tokensWithDefaultText([presentToken]) } else { newPart = .tokenWithoutDefaultText(token) @@ -325,17 +331,18 @@ extension ParseDiagnosticsGenerator { /// Ancestors that don't contain any tokens are not very interesting to merge diagnostics (because there can't be any missing tokens we can merge them with). /// Find the first ancestor that contains any tokens. - var ancestorWithTokens = node.parent + var ancestorWithMoreTokens = node.parent var index = node.index - while let unwrappedParent = ancestorWithTokens, !unwrappedParent.hasTokens { - ancestorWithTokens = unwrappedParent.parent + let nodeTokens = Array(node.tokens(viewMode: .all)) + while let unwrappedParent = ancestorWithMoreTokens, Array(unwrappedParent.tokens(viewMode: .all)) == nodeTokens { + ancestorWithMoreTokens = unwrappedParent.parent index = unwrappedParent.index } // Walk all upcoming sibling to see if they are also missing to handle them in this diagnostic. // If this is the case, handle all of them in this diagnostic. var missingNodes = [Syntax(node)] - if let parentWithTokens = ancestorWithTokens { + if let parentWithTokens = ancestorWithMoreTokens { let siblings = parentWithTokens.children(viewMode: .all) let siblingsAfter = siblings[siblings.index(after: index)...] for sibling in siblingsAfter { @@ -356,21 +363,7 @@ extension ParseDiagnosticsGenerator { } } - let changes = missingNodes.enumerated().map { (index, missingNode) -> FixIt.MultiNodeChange in - if index == 0, - let token = missingNode.as(TokenSyntax.self), - let previousTokenKind = missingNode.previousToken(viewMode: .sourceAccurate)?.tokenKind - { - if token.tokenKind.isPunctuation && !previousTokenKind.isPunctuation { - // Don't want whitespace before punctuation - return .makePresentBeforeTrivia(token) - } else if (token.tokenKind.isIdentifier || token.tokenKind.isDollarIdentifier) && previousTokenKind.isPunctuation { - // Don't want whitespace after punctuation where the following token is an identifier - return .makePresentBeforeTrivia(token) - } - } - return .makePresent(missingNode) - } + let changes = missingNodes.map { FixIt.MultiNodeChange.makePresent($0) } let fixIt = FixIt( message: InsertTokenFixIt(missingNodes: missingNodes), changes: additionalChanges + changes diff --git a/Sources/SwiftParserDiagnostics/MissingTokenError.swift b/Sources/SwiftParserDiagnostics/MissingTokenError.swift index 24b84119710..a50f57fe83a 100644 --- a/Sources/SwiftParserDiagnostics/MissingTokenError.swift +++ b/Sources/SwiftParserDiagnostics/MissingTokenError.swift @@ -109,11 +109,16 @@ extension ParseDiagnosticsGenerator { // The extraneous whitespace caused a missing identifier, output a // diagnostic inserting it instead of a diagnostic to fix the trivia // around the period. - _ = handleMissingSyntax( + let fixIt = FixIt( + message: InsertTokenFixIt(missingNodes: [Syntax(identifier)]), + changes: changes + [.makePresent(identifier, trailingTrivia: invalidToken.trailingTrivia)] + ) + addDiagnostic( identifier, - overridePosition: invalidToken.endPositionBeforeTrailingTrivia, - additionalChanges: changes, - additionalHandledNodes: [invalidTokenContainer.id] + position: invalidToken.endPositionBeforeTrailingTrivia, + MissingNodesError(missingNodes: [Syntax(identifier)]), + fixIts: [fixIt], + handledNodes: [invalidTokenContainer.id, identifier.id] ) } else { let fixIt = FixIt(message: .removeExtraneousWhitespace, changes: changes) @@ -143,7 +148,7 @@ extension ParseDiagnosticsGenerator { message: isTooMany ? .removeExtraneousDelimiters : .insertExtraClosingPounds, changes: [ .makeMissing(invalidToken), - .makePresentBeforeTrivia(missingToken), + .makePresent(missingToken), ] ) addDiagnostic( diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift index d0a1d68a20a..072a22ccde1 100644 --- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift +++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift @@ -513,7 +513,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { position: position, .consecutiveStatementsOnSameLine, fixIts: [ - FixIt(message: .insertSemicolon, changes: .makePresentBeforeTrivia(semicolon)) + FixIt(message: .insertSemicolon, changes: .makePresent(semicolon)) ], handledNodes: [semicolon.id] ) @@ -858,7 +858,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { position: position, .consecutiveDeclarationsOnSameLine, fixIts: [ - FixIt(message: .insertSemicolon, changes: .makePresentBeforeTrivia(semicolon)) + FixIt(message: .insertSemicolon, changes: .makePresent(semicolon)) ], handledNodes: [semicolon.id] ) @@ -870,27 +870,27 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor { } public override func visit(_ node: MissingDeclSyntax) -> SyntaxVisitorContinueKind { - return handleMissingSyntax(node) + return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id]) } public override func visit(_ node: MissingExprSyntax) -> SyntaxVisitorContinueKind { - return handleMissingSyntax(node) + return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id]) } public override func visit(_ node: MissingPatternSyntax) -> SyntaxVisitorContinueKind { - return handleMissingSyntax(node) + return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id]) } public override func visit(_ node: MissingStmtSyntax) -> SyntaxVisitorContinueKind { - return handleMissingSyntax(node) + return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id]) } public override func visit(_ node: MissingSyntax) -> SyntaxVisitorContinueKind { - return handleMissingSyntax(node) + return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id]) } public override func visit(_ node: MissingTypeSyntax) -> SyntaxVisitorContinueKind { - return handleMissingSyntax(node) + return handleMissingSyntax(node, additionalHandledNodes: [node.placeholder.id]) } public override func visit(_ node: OperatorDeclSyntax) -> SyntaxVisitorContinueKind { diff --git a/Sources/SwiftParserDiagnostics/PresenceUtils.swift b/Sources/SwiftParserDiagnostics/PresenceUtils.swift index fdc4a711990..71c083cbb63 100644 --- a/Sources/SwiftParserDiagnostics/PresenceUtils.swift +++ b/Sources/SwiftParserDiagnostics/PresenceUtils.swift @@ -50,72 +50,16 @@ class PresentMaker: SyntaxRewriter { let presentToken: TokenSyntax let (rawKind, text) = token.tokenKind.decomposeToRaw() if let text = text, (!text.isEmpty || rawKind == .stringSegment) { // string segments can have empty text - presentToken = TokenSyntax(token.tokenKind, presence: .present) + presentToken = token.with(\.presence, .present) } else { let newKind = TokenKind.fromRaw(kind: rawKind, text: rawKind.defaultText.map(String.init) ?? "<#\(token.tokenKind.nameForDiagnostics)#>") - presentToken = TokenSyntax(newKind, leadingTrivia: token.leadingTrivia, trailingTrivia: token.trailingTrivia, presence: .present) + presentToken = token.with(\.tokenKind, newKind).with(\.presence, .present) } - return BasicFormat().visit(presentToken) + return presentToken } else { return token } } - - override func visit(_ node: MissingDeclSyntax) -> DeclSyntax { - let leadingTriviaBeforePlaceholder: Trivia - if node.isMissingAllTokens { - leadingTriviaBeforePlaceholder = [] - } else if node.modifiers != nil { - leadingTriviaBeforePlaceholder = .space - } else { - leadingTriviaBeforePlaceholder = .newline - } - return DeclSyntax( - StructDeclSyntax( - node.unexpectedBeforeAttributes, - attributes: node.attributes, - node.unexpectedBetweenAttributesAndModifiers, - modifiers: node.modifiers, - structKeyword: .keyword(.struct, presence: .missing), - identifier: .identifier("<#declaration#>", leadingTrivia: leadingTriviaBeforePlaceholder), - memberBlock: MemberDeclBlockSyntax( - leftBrace: .leftBraceToken(presence: .missing), - members: MemberDeclListSyntax([]), - rightBrace: .rightBraceToken(presence: .missing) - ) - ) - ) - } - - override func visit(_ node: MissingExprSyntax) -> ExprSyntax { - return ExprSyntax(IdentifierExprSyntax(identifier: .identifier("<#expression#>"))) - } - - override func visit(_ node: MissingPatternSyntax) -> PatternSyntax { - return PatternSyntax(IdentifierPatternSyntax(identifier: .identifier("<#pattern#>"))) - } - - override func visit(_ node: MissingStmtSyntax) -> StmtSyntax { - return StmtSyntax( - DoStmtSyntax( - doKeyword: .keyword(.do, presence: .missing), - UnexpectedNodesSyntax([Syntax(TokenSyntax.identifier("<#statement#>"))]), - body: CodeBlockSyntax( - leftBrace: .leftBraceToken(presence: .missing), - statements: CodeBlockItemListSyntax([]), - rightBrace: .rightBraceToken(presence: .missing) - ) - ) - ) - } - - override func visit(_ node: MissingTypeSyntax) -> TypeSyntax { - return TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("<#type#>"))) - } - - override func visit(_ node: MissingSyntax) -> Syntax { - return Syntax(IdentifierExprSyntax(identifier: .identifier("<#syntax#>"))) - } } class MissingMaker: SyntaxRewriter { diff --git a/Sources/SwiftSyntax/CMakeLists.txt b/Sources/SwiftSyntax/CMakeLists.txt index 2c914bf601e..117fd67368e 100644 --- a/Sources/SwiftSyntax/CMakeLists.txt +++ b/Sources/SwiftSyntax/CMakeLists.txt @@ -12,6 +12,8 @@ add_swift_host_library(SwiftSyntax BumpPtrAllocator.swift CommonAncestor.swift IncrementalParseTransition.swift + MemoryLayout.swift + MissingNodeInitializers.swift Trivia.swift SourceLength.swift SourceLocation.swift diff --git a/Sources/SwiftSyntax/MissingNodeInitializers.swift b/Sources/SwiftSyntax/MissingNodeInitializers.swift new file mode 100644 index 00000000000..9e71c05fc89 --- /dev/null +++ b/Sources/SwiftSyntax/MissingNodeInitializers.swift @@ -0,0 +1,127 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +public extension MissingDeclSyntax { + init( + attributes: AttributeListSyntax?, + modifiers: ModifierListSyntax?, + arena: __shared SyntaxArena + ) { + self.init( + attributes: attributes, + modifiers: modifiers, + placeholder: TokenSyntax.identifier("<#declaration#>") + ) + } +} + +public extension MissingExprSyntax { + init() { + self.init( + placeholder: TokenSyntax.identifier("<#expression#>") + ) + } +} + +public extension MissingPatternSyntax { + init() { + self.init( + placeholder: TokenSyntax.identifier("<#pattern#>") + ) + } +} + +public extension MissingStmtSyntax { + init() { + self.init( + placeholder: TokenSyntax.identifier("<#statement#>") + ) + } +} + +public extension MissingTypeSyntax { + init() { + self.init( + placeholder: TokenSyntax.identifier("<#type#>") + ) + } +} + +public extension MissingSyntax { + init() { + self.init( + placeholder: TokenSyntax.identifier("<#syntax#>") + ) + } +} + +// MARK: - Raw + +public extension RawMissingDeclSyntax { + init( + attributes: RawAttributeListSyntax?, + modifiers: RawModifierListSyntax?, + arena: __shared SyntaxArena + ) { + self.init( + attributes: attributes, + modifiers: modifiers, + placeholder: RawTokenSyntax(missing: .identifier, text: "<#declaration#>", arena: arena), + arena: arena + ) + } +} + +public extension RawMissingExprSyntax { + init(arena: __shared SyntaxArena) { + self.init( + placeholder: RawTokenSyntax(missing: .identifier, text: "<#expression#>", arena: arena), + arena: arena + ) + } +} + +public extension RawMissingPatternSyntax { + init(arena: __shared SyntaxArena) { + self.init( + placeholder: RawTokenSyntax(missing: .identifier, text: "<#pattern#>", arena: arena), + arena: arena + ) + } +} + +public extension RawMissingStmtSyntax { + init(arena: __shared SyntaxArena) { + self.init( + placeholder: RawTokenSyntax(missing: .identifier, text: "<#statement#>", arena: arena), + arena: arena + ) + } +} + +public extension RawMissingTypeSyntax { + init(arena: __shared SyntaxArena) { + self.init( + placeholder: RawTokenSyntax(missing: .identifier, text: "<#type#>", arena: arena), + arena: arena + ) + } +} + +public extension RawMissingSyntax { + init(arena: __shared SyntaxArena) { + self.init( + placeholder: RawTokenSyntax(missing: .identifier, text: "<#syntax#>", arena: arena), + arena: arena + ) + } +} diff --git a/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift b/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift index 8168bfbfaa7..d1ad19f9a01 100644 --- a/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift +++ b/Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift @@ -174,6 +174,7 @@ public struct RawSyntaxTokenView { /// kind changed to `newValue`. @_spi(RawSyntax) public func withKind(_ newValue: TokenKind, arena: SyntaxArena) -> RawSyntax { + arena.addChild(self.raw.arenaReference) switch raw.rawData.payload { case .parsedToken(_): // The wholeText can't be continuous anymore. Make a materialized token. @@ -200,6 +201,7 @@ public struct RawSyntaxTokenView { /// Returns a `RawSyntax` node with the presence changed to `newValue`. @_spi(RawSyntax) public func withPresence(_ newValue: SourcePresence, arena: SyntaxArena) -> RawSyntax { + arena.addChild(self.raw.arenaReference) switch raw.rawData.payload { case .parsedToken(var payload): payload.presence = newValue @@ -269,6 +271,7 @@ public struct RawSyntaxTokenView { @_spi(RawSyntax) public func withTokenDiagnostic(tokenDiagnostic: TokenDiagnostic?, arena: SyntaxArena) -> RawSyntax { + arena.addChild(self.raw.arenaReference) switch raw.rawData.payload { case .parsedToken(var dat): dat.tokenDiagnostic = tokenDiagnostic diff --git a/Sources/SwiftSyntax/Syntax.swift b/Sources/SwiftSyntax/Syntax.swift index 4cb0e2be99e..b9af71fe0b8 100644 --- a/Sources/SwiftSyntax/Syntax.swift +++ b/Sources/SwiftSyntax/Syntax.swift @@ -660,21 +660,22 @@ public protocol SyntaxChildChoices: SyntaxProtocol {} public struct TokenSequence: Sequence { public struct Iterator: IteratorProtocol { var nextToken: TokenSyntax? - let endPosition: AbsolutePosition + /// The last token to iterate (inclusive). + let endToken: TokenSyntax? let viewMode: SyntaxTreeViewMode - init(_ token: TokenSyntax?, endPosition: AbsolutePosition, viewMode: SyntaxTreeViewMode) { + init(_ token: TokenSyntax?, endToken: TokenSyntax?, viewMode: SyntaxTreeViewMode) { self.nextToken = token - self.endPosition = endPosition + self.endToken = endToken self.viewMode = viewMode } public mutating func next() -> TokenSyntax? { guard let token = self.nextToken else { return nil } - self.nextToken = token.nextToken(viewMode: viewMode) - // Make sure we stop once we reach the end of the containing node. - if let nextTok = self.nextToken, nextTok.position >= self.endPosition { + if nextToken == endToken { self.nextToken = nil + } else { + self.nextToken = token.nextToken(viewMode: viewMode) } return token } @@ -689,7 +690,7 @@ public struct TokenSequence: Sequence { } public func makeIterator() -> Iterator { - return Iterator(node.firstToken(viewMode: viewMode), endPosition: node.endPosition, viewMode: viewMode) + return Iterator(node.firstToken(viewMode: viewMode), endToken: node.lastToken(viewMode: viewMode), viewMode: viewMode) } public func reversed() -> ReversedTokenSequence { diff --git a/Sources/SwiftSyntax/Trivia.swift b/Sources/SwiftSyntax/Trivia.swift index a2b0e0a42a2..a9b841be016 100644 --- a/Sources/SwiftSyntax/Trivia.swift +++ b/Sources/SwiftSyntax/Trivia.swift @@ -172,34 +172,6 @@ extension Trivia { } } -extension TriviaPiece { - /// Returns true if the trivia is `.newlines`, `.carriageReturns` or `.carriageReturnLineFeeds` - public var isNewline: Bool { - switch self { - case .newlines, - .carriageReturns, - .carriageReturnLineFeeds: - return true - default: - return false - } - } -} - -extension RawTriviaPiece { - /// Returns true if the trivia is `.newlines`, `.carriageReturns` or `.carriageReturnLineFeeds` - public var isNewline: Bool { - switch self { - case .newlines, - .carriageReturns, - .carriageReturnLineFeeds: - return true - default: - return false - } - } -} - extension RawTriviaPiece: TextOutputStreamable { public func write(to target: inout Target) { TriviaPiece(raw: self).write(to: &target) diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift index c1d0c1035d4..350200b9375 100644 --- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift +++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift @@ -2122,18 +2122,42 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? { return "unexpectedBetweenAttributesAndModifiers" case \MissingDeclSyntax.modifiers: return "modifiers" - case \MissingDeclSyntax.unexpectedAfterModifiers: - return "unexpectedAfterModifiers" - case \MissingExprSyntax.unexpected: - return "unexpected" - case \MissingPatternSyntax.unexpected: - return "unexpected" - case \MissingStmtSyntax.unexpected: - return "unexpected" - case \MissingSyntax.unexpected: - return "unexpected" - case \MissingTypeSyntax.unexpected: - return "unexpected" + case \MissingDeclSyntax.unexpectedBetweenModifiersAndPlaceholder: + return "unexpectedBetweenModifiersAndPlaceholder" + case \MissingDeclSyntax.placeholder: + return "placeholder" + case \MissingDeclSyntax.unexpectedAfterPlaceholder: + return "unexpectedAfterPlaceholder" + case \MissingExprSyntax.unexpectedBeforePlaceholder: + return "unexpectedBeforePlaceholder" + case \MissingExprSyntax.placeholder: + return "placeholder" + case \MissingExprSyntax.unexpectedAfterPlaceholder: + return "unexpectedAfterPlaceholder" + case \MissingPatternSyntax.unexpectedBeforePlaceholder: + return "unexpectedBeforePlaceholder" + case \MissingPatternSyntax.placeholder: + return "placeholder" + case \MissingPatternSyntax.unexpectedAfterPlaceholder: + return "unexpectedAfterPlaceholder" + case \MissingStmtSyntax.unexpectedBeforePlaceholder: + return "unexpectedBeforePlaceholder" + case \MissingStmtSyntax.placeholder: + return "placeholder" + case \MissingStmtSyntax.unexpectedAfterPlaceholder: + return "unexpectedAfterPlaceholder" + case \MissingSyntax.unexpectedBeforePlaceholder: + return "unexpectedBeforePlaceholder" + case \MissingSyntax.placeholder: + return "placeholder" + case \MissingSyntax.unexpectedAfterPlaceholder: + return "unexpectedAfterPlaceholder" + case \MissingTypeSyntax.unexpectedBeforePlaceholder: + return "unexpectedBeforePlaceholder" + case \MissingTypeSyntax.placeholder: + return "placeholder" + case \MissingTypeSyntax.unexpectedAfterPlaceholder: + return "unexpectedAfterPlaceholder" case \MoveExprSyntax.unexpectedBeforeMoveKeyword: return "unexpectedBeforeMoveKeyword" case \MoveExprSyntax.moveKeyword: diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift index 877671648de..204db5b2936 100644 --- a/Sources/SwiftSyntax/generated/Keyword.swift +++ b/Sources/SwiftSyntax/generated/Keyword.swift @@ -228,7 +228,7 @@ public enum Keyword: UInt8, Hashable { self = .`is` case "of": self = .of - default: + default: return nil } case 3: @@ -255,7 +255,7 @@ public enum Keyword: UInt8, Hashable { self = .`var` case "wrt": self = .wrt - default: + default: return nil } case 4: @@ -304,7 +304,7 @@ public enum Keyword: UInt8, Hashable { self = .`Type` case "weak": self = .weak - default: + default: return nil } case 5: @@ -357,7 +357,7 @@ public enum Keyword: UInt8, Hashable { self = .`while` case "yield": self = .yield - default: + default: return nil } case 6: @@ -404,7 +404,7 @@ public enum Keyword: UInt8, Hashable { self = .`throws` case "unsafe": self = .unsafe - default: + default: return nil } case 7: @@ -449,7 +449,7 @@ public enum Keyword: UInt8, Hashable { self = .unowned case "willSet": self = .willSet - default: + default: return nil } case 8: @@ -498,7 +498,7 @@ public enum Keyword: UInt8, Hashable { self = .`rethrows` case "Sendable": self = .Sendable - default: + default: return nil } case 9: @@ -527,7 +527,7 @@ public enum Keyword: UInt8, Hashable { self = .`typealias` case "unchecked": self = .unchecked - default: + default: return nil } case 10: @@ -552,7 +552,7 @@ public enum Keyword: UInt8, Hashable { self = .sourceFile case "visibility": self = .visibility - default: + default: return nil } case 11: @@ -587,7 +587,7 @@ public enum Keyword: UInt8, Hashable { self = .nonmutating case "unavailable": self = .unavailable - default: + default: return nil } case 12: @@ -604,7 +604,7 @@ public enum Keyword: UInt8, Hashable { self = .backDeployed case "noDerivative": self = .noDerivative - default: + default: return nil } case 13: @@ -613,7 +613,7 @@ public enum Keyword: UInt8, Hashable { self = .associativity case "unsafeAddress": self = .unsafeAddress - default: + default: return nil } case 14: @@ -632,7 +632,7 @@ public enum Keyword: UInt8, Hashable { self = .differentiable case "witness_method": self = .witness_method - default: + default: return nil } case 15: @@ -641,7 +641,7 @@ public enum Keyword: UInt8, Hashable { self = .__setter_access case "precedencegroup": self = .`precedencegroup` - default: + default: return nil } case 16: @@ -650,14 +650,14 @@ public enum Keyword: UInt8, Hashable { self = ._objcRuntimeName case "addressWithOwner": self = .addressWithOwner - default: + default: return nil } case 17: switch text { case "_RefCountedObject": self = ._RefCountedObject - default: + default: return nil } case 19: @@ -670,7 +670,7 @@ public enum Keyword: UInt8, Hashable { self = ._opaqueReturnTypeOf case "_PackageDescription": self = ._PackageDescription - default: + default: return nil } case 20: @@ -681,21 +681,21 @@ public enum Keyword: UInt8, Hashable { self = ._originallyDefinedIn case "unsafeMutableAddress": self = .unsafeMutableAddress - default: + default: return nil } case 21: switch text { case "_unavailableFromAsync": self = ._unavailableFromAsync - default: + default: return nil } case 22: switch text { case "addressWithNativeOwner": self = .addressWithNativeOwner - default: + default: return nil } case 23: @@ -706,24 +706,24 @@ public enum Keyword: UInt8, Hashable { self = ._projectedValueProperty case "mutableAddressWithOwner": self = .mutableAddressWithOwner - default: + default: return nil } case 29: switch text { case "mutableAddressWithNativeOwner": self = .mutableAddressWithNativeOwner - default: + default: return nil } case 31: switch text { case "_swift_native_objc_runtime_base": self = ._swift_native_objc_runtime_base - default: + default: return nil } - default: + default: return nil } } diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift index d7e69654697..a91643e1fe9 100644 --- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift +++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift @@ -48,8 +48,8 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable { /// Create a `DeclSyntax` node from a specialized optional syntax node. public init?(_ syntax: S?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(syntax) } @@ -63,8 +63,8 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable { /// Create a `DeclSyntax` node from a specialized optional syntax node. public init?(fromProtocol syntax: DeclSyntaxProtocol?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(fromProtocol: syntax) } @@ -119,29 +119,29 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(AccessorDeclSyntax.self), - .node(ActorDeclSyntax.self), - .node(AssociatedtypeDeclSyntax.self), - .node(ClassDeclSyntax.self), - .node(DeinitializerDeclSyntax.self), - .node(EditorPlaceholderDeclSyntax.self), - .node(EnumCaseDeclSyntax.self), - .node(EnumDeclSyntax.self), - .node(ExtensionDeclSyntax.self), - .node(FunctionDeclSyntax.self), - .node(IfConfigDeclSyntax.self), - .node(ImportDeclSyntax.self), - .node(InitializerDeclSyntax.self), - .node(MacroDeclSyntax.self), - .node(MacroExpansionDeclSyntax.self), - .node(MissingDeclSyntax.self), - .node(OperatorDeclSyntax.self), - .node(PoundSourceLocationSyntax.self), - .node(PrecedenceGroupDeclSyntax.self), - .node(ProtocolDeclSyntax.self), - .node(StructDeclSyntax.self), - .node(SubscriptDeclSyntax.self), - .node(TypealiasDeclSyntax.self), + .node(AccessorDeclSyntax.self), + .node(ActorDeclSyntax.self), + .node(AssociatedtypeDeclSyntax.self), + .node(ClassDeclSyntax.self), + .node(DeinitializerDeclSyntax.self), + .node(EditorPlaceholderDeclSyntax.self), + .node(EnumCaseDeclSyntax.self), + .node(EnumDeclSyntax.self), + .node(ExtensionDeclSyntax.self), + .node(FunctionDeclSyntax.self), + .node(IfConfigDeclSyntax.self), + .node(ImportDeclSyntax.self), + .node(InitializerDeclSyntax.self), + .node(MacroDeclSyntax.self), + .node(MacroExpansionDeclSyntax.self), + .node(MissingDeclSyntax.self), + .node(OperatorDeclSyntax.self), + .node(PoundSourceLocationSyntax.self), + .node(PrecedenceGroupDeclSyntax.self), + .node(ProtocolDeclSyntax.self), + .node(StructDeclSyntax.self), + .node(SubscriptDeclSyntax.self), + .node(TypealiasDeclSyntax.self), .node(VariableDeclSyntax.self) ]) } @@ -183,8 +183,8 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Create a `ExprSyntax` node from a specialized optional syntax node. public init?(_ syntax: S?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(syntax) } @@ -198,8 +198,8 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// Create a `ExprSyntax` node from a specialized optional syntax node. public init?(fromProtocol syntax: ExprSyntaxProtocol?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(fromProtocol: syntax) } @@ -254,53 +254,53 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(ArrayExprSyntax.self), - .node(ArrowExprSyntax.self), - .node(AsExprSyntax.self), - .node(AssignmentExprSyntax.self), - .node(AwaitExprSyntax.self), - .node(BinaryOperatorExprSyntax.self), - .node(BooleanLiteralExprSyntax.self), - .node(BorrowExprSyntax.self), - .node(ClosureExprSyntax.self), - .node(DictionaryExprSyntax.self), - .node(DiscardAssignmentExprSyntax.self), - .node(EditorPlaceholderExprSyntax.self), - .node(FloatLiteralExprSyntax.self), - .node(ForcedValueExprSyntax.self), - .node(FunctionCallExprSyntax.self), - .node(IdentifierExprSyntax.self), - .node(IfExprSyntax.self), - .node(InOutExprSyntax.self), - .node(InfixOperatorExprSyntax.self), - .node(IntegerLiteralExprSyntax.self), - .node(IsExprSyntax.self), - .node(KeyPathExprSyntax.self), - .node(MacroExpansionExprSyntax.self), - .node(MemberAccessExprSyntax.self), - .node(MissingExprSyntax.self), - .node(MoveExprSyntax.self), - .node(NilLiteralExprSyntax.self), - .node(OptionalChainingExprSyntax.self), - .node(PackElementExprSyntax.self), - .node(PackExpansionExprSyntax.self), - .node(PostfixIfConfigExprSyntax.self), - .node(PostfixUnaryExprSyntax.self), - .node(PrefixOperatorExprSyntax.self), - .node(RegexLiteralExprSyntax.self), - .node(SequenceExprSyntax.self), - .node(SpecializeExprSyntax.self), - .node(StringLiteralExprSyntax.self), - .node(SubscriptExprSyntax.self), - .node(SuperRefExprSyntax.self), - .node(SwitchExprSyntax.self), - .node(TernaryExprSyntax.self), - .node(TryExprSyntax.self), - .node(TupleExprSyntax.self), - .node(TypeExprSyntax.self), - .node(UnresolvedAsExprSyntax.self), - .node(UnresolvedIsExprSyntax.self), - .node(UnresolvedPatternExprSyntax.self), + .node(ArrayExprSyntax.self), + .node(ArrowExprSyntax.self), + .node(AsExprSyntax.self), + .node(AssignmentExprSyntax.self), + .node(AwaitExprSyntax.self), + .node(BinaryOperatorExprSyntax.self), + .node(BooleanLiteralExprSyntax.self), + .node(BorrowExprSyntax.self), + .node(ClosureExprSyntax.self), + .node(DictionaryExprSyntax.self), + .node(DiscardAssignmentExprSyntax.self), + .node(EditorPlaceholderExprSyntax.self), + .node(FloatLiteralExprSyntax.self), + .node(ForcedValueExprSyntax.self), + .node(FunctionCallExprSyntax.self), + .node(IdentifierExprSyntax.self), + .node(IfExprSyntax.self), + .node(InOutExprSyntax.self), + .node(InfixOperatorExprSyntax.self), + .node(IntegerLiteralExprSyntax.self), + .node(IsExprSyntax.self), + .node(KeyPathExprSyntax.self), + .node(MacroExpansionExprSyntax.self), + .node(MemberAccessExprSyntax.self), + .node(MissingExprSyntax.self), + .node(MoveExprSyntax.self), + .node(NilLiteralExprSyntax.self), + .node(OptionalChainingExprSyntax.self), + .node(PackElementExprSyntax.self), + .node(PackExpansionExprSyntax.self), + .node(PostfixIfConfigExprSyntax.self), + .node(PostfixUnaryExprSyntax.self), + .node(PrefixOperatorExprSyntax.self), + .node(RegexLiteralExprSyntax.self), + .node(SequenceExprSyntax.self), + .node(SpecializeExprSyntax.self), + .node(StringLiteralExprSyntax.self), + .node(SubscriptExprSyntax.self), + .node(SuperRefExprSyntax.self), + .node(SwitchExprSyntax.self), + .node(TernaryExprSyntax.self), + .node(TryExprSyntax.self), + .node(TupleExprSyntax.self), + .node(TypeExprSyntax.self), + .node(UnresolvedAsExprSyntax.self), + .node(UnresolvedIsExprSyntax.self), + .node(UnresolvedPatternExprSyntax.self), .node(UnresolvedTernaryExprSyntax.self) ]) } @@ -342,8 +342,8 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable { /// Create a `PatternSyntax` node from a specialized optional syntax node. public init?(_ syntax: S?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(syntax) } @@ -357,8 +357,8 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable { /// Create a `PatternSyntax` node from a specialized optional syntax node. public init?(fromProtocol syntax: PatternSyntaxProtocol?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(fromProtocol: syntax) } @@ -413,12 +413,12 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(ExpressionPatternSyntax.self), - .node(IdentifierPatternSyntax.self), - .node(IsTypePatternSyntax.self), - .node(MissingPatternSyntax.self), - .node(TuplePatternSyntax.self), - .node(ValueBindingPatternSyntax.self), + .node(ExpressionPatternSyntax.self), + .node(IdentifierPatternSyntax.self), + .node(IsTypePatternSyntax.self), + .node(MissingPatternSyntax.self), + .node(TuplePatternSyntax.self), + .node(ValueBindingPatternSyntax.self), .node(WildcardPatternSyntax.self) ]) } @@ -460,8 +460,8 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { /// Create a `StmtSyntax` node from a specialized optional syntax node. public init?(_ syntax: S?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(syntax) } @@ -475,8 +475,8 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { /// Create a `StmtSyntax` node from a specialized optional syntax node. public init?(fromProtocol syntax: StmtSyntaxProtocol?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(fromProtocol: syntax) } @@ -531,21 +531,21 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(BreakStmtSyntax.self), - .node(ContinueStmtSyntax.self), - .node(DeferStmtSyntax.self), - .node(DoStmtSyntax.self), - .node(ExpressionStmtSyntax.self), - .node(FallthroughStmtSyntax.self), - .node(ForInStmtSyntax.self), - .node(ForgetStmtSyntax.self), - .node(GuardStmtSyntax.self), - .node(LabeledStmtSyntax.self), - .node(MissingStmtSyntax.self), - .node(RepeatWhileStmtSyntax.self), - .node(ReturnStmtSyntax.self), - .node(ThrowStmtSyntax.self), - .node(WhileStmtSyntax.self), + .node(BreakStmtSyntax.self), + .node(ContinueStmtSyntax.self), + .node(DeferStmtSyntax.self), + .node(DoStmtSyntax.self), + .node(ExpressionStmtSyntax.self), + .node(FallthroughStmtSyntax.self), + .node(ForInStmtSyntax.self), + .node(ForgetStmtSyntax.self), + .node(GuardStmtSyntax.self), + .node(LabeledStmtSyntax.self), + .node(MissingStmtSyntax.self), + .node(RepeatWhileStmtSyntax.self), + .node(ReturnStmtSyntax.self), + .node(ThrowStmtSyntax.self), + .node(WhileStmtSyntax.self), .node(YieldStmtSyntax.self) ]) } @@ -587,8 +587,8 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { /// Create a `TypeSyntax` node from a specialized optional syntax node. public init?(_ syntax: S?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(syntax) } @@ -602,8 +602,8 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { /// Create a `TypeSyntax` node from a specialized optional syntax node. public init?(fromProtocol syntax: TypeSyntaxProtocol?) { - guard let syntax = syntax else { - return nil + guard let syntax = syntax else { + return nil } self.init(fromProtocol: syntax) } @@ -658,22 +658,22 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public static var structure: SyntaxNodeStructure { return .choices([ - .node(ArrayTypeSyntax.self), - .node(AttributedTypeSyntax.self), - .node(ClassRestrictionTypeSyntax.self), - .node(CompositionTypeSyntax.self), - .node(ConstrainedSugarTypeSyntax.self), - .node(DictionaryTypeSyntax.self), - .node(FunctionTypeSyntax.self), - .node(ImplicitlyUnwrappedOptionalTypeSyntax.self), - .node(MemberTypeIdentifierSyntax.self), - .node(MetatypeTypeSyntax.self), - .node(MissingTypeSyntax.self), - .node(NamedOpaqueReturnTypeSyntax.self), - .node(OptionalTypeSyntax.self), - .node(PackExpansionTypeSyntax.self), - .node(PackReferenceTypeSyntax.self), - .node(SimpleTypeIdentifierSyntax.self), + .node(ArrayTypeSyntax.self), + .node(AttributedTypeSyntax.self), + .node(ClassRestrictionTypeSyntax.self), + .node(CompositionTypeSyntax.self), + .node(ConstrainedSugarTypeSyntax.self), + .node(DictionaryTypeSyntax.self), + .node(FunctionTypeSyntax.self), + .node(ImplicitlyUnwrappedOptionalTypeSyntax.self), + .node(MemberTypeIdentifierSyntax.self), + .node(MetatypeTypeSyntax.self), + .node(MissingTypeSyntax.self), + .node(NamedOpaqueReturnTypeSyntax.self), + .node(OptionalTypeSyntax.self), + .node(PackExpansionTypeSyntax.self), + .node(PackReferenceTypeSyntax.self), + .node(SimpleTypeIdentifierSyntax.self), .node(TupleTypeSyntax.self) ]) } @@ -682,274 +682,274 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable { extension Syntax { public static var structure: SyntaxNodeStructure { return .choices([ - .node(TokenSyntax.self), - .node(AccessPathComponentSyntax.self), - .node(AccessPathSyntax.self), - .node(AccessorBlockSyntax.self), - .node(AccessorDeclSyntax.self), - .node(AccessorEffectSpecifiersSyntax.self), - .node(AccessorListSyntax.self), - .node(AccessorParameterSyntax.self), - .node(ActorDeclSyntax.self), - .node(ArrayElementListSyntax.self), - .node(ArrayElementSyntax.self), - .node(ArrayExprSyntax.self), - .node(ArrayTypeSyntax.self), - .node(ArrowExprSyntax.self), - .node(AsExprSyntax.self), - .node(AssignmentExprSyntax.self), - .node(AssociatedtypeDeclSyntax.self), - .node(AttributeListSyntax.self), - .node(AttributeSyntax.self), - .node(AttributedTypeSyntax.self), - .node(AvailabilityArgumentSyntax.self), - .node(AvailabilityConditionSyntax.self), - .node(AvailabilityEntrySyntax.self), - .node(AvailabilityLabeledArgumentSyntax.self), - .node(AvailabilitySpecListSyntax.self), - .node(AvailabilityVersionRestrictionListEntrySyntax.self), - .node(AvailabilityVersionRestrictionListSyntax.self), - .node(AvailabilityVersionRestrictionSyntax.self), - .node(AwaitExprSyntax.self), - .node(BackDeployedAttributeSpecListSyntax.self), - .node(BinaryOperatorExprSyntax.self), - .node(BooleanLiteralExprSyntax.self), - .node(BorrowExprSyntax.self), - .node(BreakStmtSyntax.self), - .node(CaseItemListSyntax.self), - .node(CaseItemSyntax.self), - .node(CatchClauseListSyntax.self), - .node(CatchClauseSyntax.self), - .node(CatchItemListSyntax.self), - .node(CatchItemSyntax.self), - .node(ClassDeclSyntax.self), - .node(ClassRestrictionTypeSyntax.self), - .node(ClosureCaptureItemListSyntax.self), - .node(ClosureCaptureItemSpecifierSyntax.self), - .node(ClosureCaptureItemSyntax.self), - .node(ClosureCaptureSignatureSyntax.self), - .node(ClosureExprSyntax.self), - .node(ClosureParamListSyntax.self), - .node(ClosureParamSyntax.self), - .node(ClosureParameterClauseSyntax.self), - .node(ClosureParameterListSyntax.self), - .node(ClosureParameterSyntax.self), - .node(ClosureSignatureSyntax.self), - .node(CodeBlockItemListSyntax.self), - .node(CodeBlockItemSyntax.self), - .node(CodeBlockSyntax.self), - .node(CompositionTypeElementListSyntax.self), - .node(CompositionTypeElementSyntax.self), - .node(CompositionTypeSyntax.self), - .node(ConditionElementListSyntax.self), - .node(ConditionElementSyntax.self), - .node(ConformanceRequirementSyntax.self), - .node(ConstrainedSugarTypeSyntax.self), - .node(ContinueStmtSyntax.self), - .node(ConventionAttributeArgumentsSyntax.self), - .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), - .node(DeclModifierDetailSyntax.self), - .node(DeclModifierSyntax.self), - .node(DeclNameArgumentListSyntax.self), - .node(DeclNameArgumentSyntax.self), - .node(DeclNameArgumentsSyntax.self), - .node(DeclNameSyntax.self), - .node(DeferStmtSyntax.self), - .node(DeinitializerDeclSyntax.self), - .node(DerivativeRegistrationAttributeArgumentsSyntax.self), - .node(DesignatedTypeElementSyntax.self), - .node(DesignatedTypeListSyntax.self), - .node(DictionaryElementListSyntax.self), - .node(DictionaryElementSyntax.self), - .node(DictionaryExprSyntax.self), - .node(DictionaryTypeSyntax.self), - .node(DifferentiabilityParamListSyntax.self), - .node(DifferentiabilityParamSyntax.self), - .node(DifferentiabilityParamsClauseSyntax.self), - .node(DifferentiabilityParamsSyntax.self), - .node(DifferentiableAttributeArgumentsSyntax.self), - .node(DiscardAssignmentExprSyntax.self), - .node(DoStmtSyntax.self), - .node(DocumentationAttributeArgumentSyntax.self), - .node(DocumentationAttributeArgumentsSyntax.self), - .node(DynamicReplacementArgumentsSyntax.self), - .node(EditorPlaceholderDeclSyntax.self), - .node(EditorPlaceholderExprSyntax.self), - .node(EffectsArgumentsSyntax.self), - .node(EnumCaseDeclSyntax.self), - .node(EnumCaseElementListSyntax.self), - .node(EnumCaseElementSyntax.self), - .node(EnumCaseParameterClauseSyntax.self), - .node(EnumCaseParameterListSyntax.self), - .node(EnumCaseParameterSyntax.self), - .node(EnumDeclSyntax.self), - .node(ExposeAttributeArgumentsSyntax.self), - .node(ExprListSyntax.self), - .node(ExpressionPatternSyntax.self), - .node(ExpressionSegmentSyntax.self), - .node(ExpressionStmtSyntax.self), - .node(ExtensionDeclSyntax.self), - .node(FallthroughStmtSyntax.self), - .node(FloatLiteralExprSyntax.self), - .node(ForInStmtSyntax.self), - .node(ForcedValueExprSyntax.self), - .node(ForgetStmtSyntax.self), - .node(FunctionCallExprSyntax.self), - .node(FunctionDeclSyntax.self), - .node(FunctionEffectSpecifiersSyntax.self), - .node(FunctionParameterListSyntax.self), - .node(FunctionParameterSyntax.self), - .node(FunctionSignatureSyntax.self), - .node(FunctionTypeSyntax.self), - .node(GenericArgumentClauseSyntax.self), - .node(GenericArgumentListSyntax.self), - .node(GenericArgumentSyntax.self), - .node(GenericParameterClauseSyntax.self), - .node(GenericParameterListSyntax.self), - .node(GenericParameterSyntax.self), - .node(GenericRequirementListSyntax.self), - .node(GenericRequirementSyntax.self), - .node(GenericWhereClauseSyntax.self), - .node(GuardStmtSyntax.self), - .node(IdentifierExprSyntax.self), - .node(IdentifierPatternSyntax.self), - .node(IfConfigClauseListSyntax.self), - .node(IfConfigClauseSyntax.self), - .node(IfConfigDeclSyntax.self), - .node(IfExprSyntax.self), - .node(ImplementsAttributeArgumentsSyntax.self), - .node(ImplicitlyUnwrappedOptionalTypeSyntax.self), - .node(ImportDeclSyntax.self), - .node(InOutExprSyntax.self), - .node(InfixOperatorExprSyntax.self), - .node(InheritedTypeListSyntax.self), - .node(InheritedTypeSyntax.self), - .node(InitializerClauseSyntax.self), - .node(InitializerDeclSyntax.self), - .node(IntegerLiteralExprSyntax.self), - .node(IsExprSyntax.self), - .node(IsTypePatternSyntax.self), - .node(KeyPathComponentListSyntax.self), - .node(KeyPathComponentSyntax.self), - .node(KeyPathExprSyntax.self), - .node(KeyPathOptionalComponentSyntax.self), - .node(KeyPathPropertyComponentSyntax.self), - .node(KeyPathSubscriptComponentSyntax.self), - .node(LabeledSpecializeEntrySyntax.self), - .node(LabeledStmtSyntax.self), - .node(LayoutRequirementSyntax.self), - .node(MacroDeclSyntax.self), - .node(MacroExpansionDeclSyntax.self), - .node(MacroExpansionExprSyntax.self), - .node(MatchingPatternConditionSyntax.self), - .node(MemberAccessExprSyntax.self), - .node(MemberDeclBlockSyntax.self), - .node(MemberDeclListItemSyntax.self), - .node(MemberDeclListSyntax.self), - .node(MemberTypeIdentifierSyntax.self), - .node(MetatypeTypeSyntax.self), - .node(MissingDeclSyntax.self), - .node(MissingExprSyntax.self), - .node(MissingPatternSyntax.self), - .node(MissingStmtSyntax.self), - .node(MissingSyntax.self), - .node(MissingTypeSyntax.self), - .node(ModifierListSyntax.self), - .node(MoveExprSyntax.self), - .node(MultipleTrailingClosureElementListSyntax.self), - .node(MultipleTrailingClosureElementSyntax.self), - .node(NamedOpaqueReturnTypeSyntax.self), - .node(NilLiteralExprSyntax.self), - .node(ObjCSelectorPieceSyntax.self), - .node(ObjCSelectorSyntax.self), - .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), - .node(OperatorDeclSyntax.self), - .node(OperatorPrecedenceAndTypesSyntax.self), - .node(OptionalBindingConditionSyntax.self), - .node(OptionalChainingExprSyntax.self), - .node(OptionalTypeSyntax.self), - .node(OriginallyDefinedInArgumentsSyntax.self), - .node(PackElementExprSyntax.self), - .node(PackExpansionExprSyntax.self), - .node(PackExpansionTypeSyntax.self), - .node(PackReferenceTypeSyntax.self), - .node(ParameterClauseSyntax.self), - .node(PatternBindingListSyntax.self), - .node(PatternBindingSyntax.self), - .node(PostfixIfConfigExprSyntax.self), - .node(PostfixUnaryExprSyntax.self), - .node(PoundSourceLocationArgsSyntax.self), - .node(PoundSourceLocationSyntax.self), - .node(PrecedenceGroupAssignmentSyntax.self), - .node(PrecedenceGroupAssociativitySyntax.self), - .node(PrecedenceGroupAttributeListSyntax.self), - .node(PrecedenceGroupDeclSyntax.self), - .node(PrecedenceGroupNameElementSyntax.self), - .node(PrecedenceGroupNameListSyntax.self), - .node(PrecedenceGroupRelationSyntax.self), - .node(PrefixOperatorExprSyntax.self), - .node(PrimaryAssociatedTypeClauseSyntax.self), - .node(PrimaryAssociatedTypeListSyntax.self), - .node(PrimaryAssociatedTypeSyntax.self), - .node(ProtocolDeclSyntax.self), - .node(QualifiedDeclNameSyntax.self), - .node(RegexLiteralExprSyntax.self), - .node(RepeatWhileStmtSyntax.self), - .node(ReturnClauseSyntax.self), - .node(ReturnStmtSyntax.self), - .node(SameTypeRequirementSyntax.self), - .node(SequenceExprSyntax.self), - .node(SimpleTypeIdentifierSyntax.self), - .node(SourceFileSyntax.self), - .node(SpecializeAttributeSpecListSyntax.self), - .node(SpecializeExprSyntax.self), - .node(StringLiteralExprSyntax.self), - .node(StringLiteralSegmentsSyntax.self), - .node(StringSegmentSyntax.self), - .node(StructDeclSyntax.self), - .node(SubscriptDeclSyntax.self), - .node(SubscriptExprSyntax.self), - .node(SuperRefExprSyntax.self), - .node(SwitchCaseLabelSyntax.self), - .node(SwitchCaseListSyntax.self), - .node(SwitchCaseSyntax.self), - .node(SwitchDefaultLabelSyntax.self), - .node(SwitchExprSyntax.self), - .node(TargetFunctionEntrySyntax.self), - .node(TernaryExprSyntax.self), - .node(ThrowStmtSyntax.self), - .node(TryExprSyntax.self), - .node(TupleExprElementListSyntax.self), - .node(TupleExprElementSyntax.self), - .node(TupleExprSyntax.self), - .node(TuplePatternElementListSyntax.self), - .node(TuplePatternElementSyntax.self), - .node(TuplePatternSyntax.self), - .node(TupleTypeElementListSyntax.self), - .node(TupleTypeElementSyntax.self), - .node(TupleTypeSyntax.self), - .node(TypeAnnotationSyntax.self), - .node(TypeEffectSpecifiersSyntax.self), - .node(TypeExprSyntax.self), - .node(TypeInheritanceClauseSyntax.self), - .node(TypeInitializerClauseSyntax.self), - .node(TypealiasDeclSyntax.self), - .node(UnavailableFromAsyncArgumentsSyntax.self), - .node(UnderscorePrivateAttributeArgumentsSyntax.self), - .node(UnexpectedNodesSyntax.self), - .node(UnresolvedAsExprSyntax.self), - .node(UnresolvedIsExprSyntax.self), - .node(UnresolvedPatternExprSyntax.self), - .node(UnresolvedTernaryExprSyntax.self), - .node(ValueBindingPatternSyntax.self), - .node(VariableDeclSyntax.self), - .node(VersionTupleSyntax.self), - .node(WhereClauseSyntax.self), - .node(WhileStmtSyntax.self), - .node(WildcardPatternSyntax.self), - .node(YieldExprListElementSyntax.self), - .node(YieldExprListSyntax.self), - .node(YieldListSyntax.self), + .node(TokenSyntax.self), + .node(AccessPathComponentSyntax.self), + .node(AccessPathSyntax.self), + .node(AccessorBlockSyntax.self), + .node(AccessorDeclSyntax.self), + .node(AccessorEffectSpecifiersSyntax.self), + .node(AccessorListSyntax.self), + .node(AccessorParameterSyntax.self), + .node(ActorDeclSyntax.self), + .node(ArrayElementListSyntax.self), + .node(ArrayElementSyntax.self), + .node(ArrayExprSyntax.self), + .node(ArrayTypeSyntax.self), + .node(ArrowExprSyntax.self), + .node(AsExprSyntax.self), + .node(AssignmentExprSyntax.self), + .node(AssociatedtypeDeclSyntax.self), + .node(AttributeListSyntax.self), + .node(AttributeSyntax.self), + .node(AttributedTypeSyntax.self), + .node(AvailabilityArgumentSyntax.self), + .node(AvailabilityConditionSyntax.self), + .node(AvailabilityEntrySyntax.self), + .node(AvailabilityLabeledArgumentSyntax.self), + .node(AvailabilitySpecListSyntax.self), + .node(AvailabilityVersionRestrictionListEntrySyntax.self), + .node(AvailabilityVersionRestrictionListSyntax.self), + .node(AvailabilityVersionRestrictionSyntax.self), + .node(AwaitExprSyntax.self), + .node(BackDeployedAttributeSpecListSyntax.self), + .node(BinaryOperatorExprSyntax.self), + .node(BooleanLiteralExprSyntax.self), + .node(BorrowExprSyntax.self), + .node(BreakStmtSyntax.self), + .node(CaseItemListSyntax.self), + .node(CaseItemSyntax.self), + .node(CatchClauseListSyntax.self), + .node(CatchClauseSyntax.self), + .node(CatchItemListSyntax.self), + .node(CatchItemSyntax.self), + .node(ClassDeclSyntax.self), + .node(ClassRestrictionTypeSyntax.self), + .node(ClosureCaptureItemListSyntax.self), + .node(ClosureCaptureItemSpecifierSyntax.self), + .node(ClosureCaptureItemSyntax.self), + .node(ClosureCaptureSignatureSyntax.self), + .node(ClosureExprSyntax.self), + .node(ClosureParamListSyntax.self), + .node(ClosureParamSyntax.self), + .node(ClosureParameterClauseSyntax.self), + .node(ClosureParameterListSyntax.self), + .node(ClosureParameterSyntax.self), + .node(ClosureSignatureSyntax.self), + .node(CodeBlockItemListSyntax.self), + .node(CodeBlockItemSyntax.self), + .node(CodeBlockSyntax.self), + .node(CompositionTypeElementListSyntax.self), + .node(CompositionTypeElementSyntax.self), + .node(CompositionTypeSyntax.self), + .node(ConditionElementListSyntax.self), + .node(ConditionElementSyntax.self), + .node(ConformanceRequirementSyntax.self), + .node(ConstrainedSugarTypeSyntax.self), + .node(ContinueStmtSyntax.self), + .node(ConventionAttributeArgumentsSyntax.self), + .node(ConventionWitnessMethodAttributeArgumentsSyntax.self), + .node(DeclModifierDetailSyntax.self), + .node(DeclModifierSyntax.self), + .node(DeclNameArgumentListSyntax.self), + .node(DeclNameArgumentSyntax.self), + .node(DeclNameArgumentsSyntax.self), + .node(DeclNameSyntax.self), + .node(DeferStmtSyntax.self), + .node(DeinitializerDeclSyntax.self), + .node(DerivativeRegistrationAttributeArgumentsSyntax.self), + .node(DesignatedTypeElementSyntax.self), + .node(DesignatedTypeListSyntax.self), + .node(DictionaryElementListSyntax.self), + .node(DictionaryElementSyntax.self), + .node(DictionaryExprSyntax.self), + .node(DictionaryTypeSyntax.self), + .node(DifferentiabilityParamListSyntax.self), + .node(DifferentiabilityParamSyntax.self), + .node(DifferentiabilityParamsClauseSyntax.self), + .node(DifferentiabilityParamsSyntax.self), + .node(DifferentiableAttributeArgumentsSyntax.self), + .node(DiscardAssignmentExprSyntax.self), + .node(DoStmtSyntax.self), + .node(DocumentationAttributeArgumentSyntax.self), + .node(DocumentationAttributeArgumentsSyntax.self), + .node(DynamicReplacementArgumentsSyntax.self), + .node(EditorPlaceholderDeclSyntax.self), + .node(EditorPlaceholderExprSyntax.self), + .node(EffectsArgumentsSyntax.self), + .node(EnumCaseDeclSyntax.self), + .node(EnumCaseElementListSyntax.self), + .node(EnumCaseElementSyntax.self), + .node(EnumCaseParameterClauseSyntax.self), + .node(EnumCaseParameterListSyntax.self), + .node(EnumCaseParameterSyntax.self), + .node(EnumDeclSyntax.self), + .node(ExposeAttributeArgumentsSyntax.self), + .node(ExprListSyntax.self), + .node(ExpressionPatternSyntax.self), + .node(ExpressionSegmentSyntax.self), + .node(ExpressionStmtSyntax.self), + .node(ExtensionDeclSyntax.self), + .node(FallthroughStmtSyntax.self), + .node(FloatLiteralExprSyntax.self), + .node(ForInStmtSyntax.self), + .node(ForcedValueExprSyntax.self), + .node(ForgetStmtSyntax.self), + .node(FunctionCallExprSyntax.self), + .node(FunctionDeclSyntax.self), + .node(FunctionEffectSpecifiersSyntax.self), + .node(FunctionParameterListSyntax.self), + .node(FunctionParameterSyntax.self), + .node(FunctionSignatureSyntax.self), + .node(FunctionTypeSyntax.self), + .node(GenericArgumentClauseSyntax.self), + .node(GenericArgumentListSyntax.self), + .node(GenericArgumentSyntax.self), + .node(GenericParameterClauseSyntax.self), + .node(GenericParameterListSyntax.self), + .node(GenericParameterSyntax.self), + .node(GenericRequirementListSyntax.self), + .node(GenericRequirementSyntax.self), + .node(GenericWhereClauseSyntax.self), + .node(GuardStmtSyntax.self), + .node(IdentifierExprSyntax.self), + .node(IdentifierPatternSyntax.self), + .node(IfConfigClauseListSyntax.self), + .node(IfConfigClauseSyntax.self), + .node(IfConfigDeclSyntax.self), + .node(IfExprSyntax.self), + .node(ImplementsAttributeArgumentsSyntax.self), + .node(ImplicitlyUnwrappedOptionalTypeSyntax.self), + .node(ImportDeclSyntax.self), + .node(InOutExprSyntax.self), + .node(InfixOperatorExprSyntax.self), + .node(InheritedTypeListSyntax.self), + .node(InheritedTypeSyntax.self), + .node(InitializerClauseSyntax.self), + .node(InitializerDeclSyntax.self), + .node(IntegerLiteralExprSyntax.self), + .node(IsExprSyntax.self), + .node(IsTypePatternSyntax.self), + .node(KeyPathComponentListSyntax.self), + .node(KeyPathComponentSyntax.self), + .node(KeyPathExprSyntax.self), + .node(KeyPathOptionalComponentSyntax.self), + .node(KeyPathPropertyComponentSyntax.self), + .node(KeyPathSubscriptComponentSyntax.self), + .node(LabeledSpecializeEntrySyntax.self), + .node(LabeledStmtSyntax.self), + .node(LayoutRequirementSyntax.self), + .node(MacroDeclSyntax.self), + .node(MacroExpansionDeclSyntax.self), + .node(MacroExpansionExprSyntax.self), + .node(MatchingPatternConditionSyntax.self), + .node(MemberAccessExprSyntax.self), + .node(MemberDeclBlockSyntax.self), + .node(MemberDeclListItemSyntax.self), + .node(MemberDeclListSyntax.self), + .node(MemberTypeIdentifierSyntax.self), + .node(MetatypeTypeSyntax.self), + .node(MissingDeclSyntax.self), + .node(MissingExprSyntax.self), + .node(MissingPatternSyntax.self), + .node(MissingStmtSyntax.self), + .node(MissingSyntax.self), + .node(MissingTypeSyntax.self), + .node(ModifierListSyntax.self), + .node(MoveExprSyntax.self), + .node(MultipleTrailingClosureElementListSyntax.self), + .node(MultipleTrailingClosureElementSyntax.self), + .node(NamedOpaqueReturnTypeSyntax.self), + .node(NilLiteralExprSyntax.self), + .node(ObjCSelectorPieceSyntax.self), + .node(ObjCSelectorSyntax.self), + .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self), + .node(OperatorDeclSyntax.self), + .node(OperatorPrecedenceAndTypesSyntax.self), + .node(OptionalBindingConditionSyntax.self), + .node(OptionalChainingExprSyntax.self), + .node(OptionalTypeSyntax.self), + .node(OriginallyDefinedInArgumentsSyntax.self), + .node(PackElementExprSyntax.self), + .node(PackExpansionExprSyntax.self), + .node(PackExpansionTypeSyntax.self), + .node(PackReferenceTypeSyntax.self), + .node(ParameterClauseSyntax.self), + .node(PatternBindingListSyntax.self), + .node(PatternBindingSyntax.self), + .node(PostfixIfConfigExprSyntax.self), + .node(PostfixUnaryExprSyntax.self), + .node(PoundSourceLocationArgsSyntax.self), + .node(PoundSourceLocationSyntax.self), + .node(PrecedenceGroupAssignmentSyntax.self), + .node(PrecedenceGroupAssociativitySyntax.self), + .node(PrecedenceGroupAttributeListSyntax.self), + .node(PrecedenceGroupDeclSyntax.self), + .node(PrecedenceGroupNameElementSyntax.self), + .node(PrecedenceGroupNameListSyntax.self), + .node(PrecedenceGroupRelationSyntax.self), + .node(PrefixOperatorExprSyntax.self), + .node(PrimaryAssociatedTypeClauseSyntax.self), + .node(PrimaryAssociatedTypeListSyntax.self), + .node(PrimaryAssociatedTypeSyntax.self), + .node(ProtocolDeclSyntax.self), + .node(QualifiedDeclNameSyntax.self), + .node(RegexLiteralExprSyntax.self), + .node(RepeatWhileStmtSyntax.self), + .node(ReturnClauseSyntax.self), + .node(ReturnStmtSyntax.self), + .node(SameTypeRequirementSyntax.self), + .node(SequenceExprSyntax.self), + .node(SimpleTypeIdentifierSyntax.self), + .node(SourceFileSyntax.self), + .node(SpecializeAttributeSpecListSyntax.self), + .node(SpecializeExprSyntax.self), + .node(StringLiteralExprSyntax.self), + .node(StringLiteralSegmentsSyntax.self), + .node(StringSegmentSyntax.self), + .node(StructDeclSyntax.self), + .node(SubscriptDeclSyntax.self), + .node(SubscriptExprSyntax.self), + .node(SuperRefExprSyntax.self), + .node(SwitchCaseLabelSyntax.self), + .node(SwitchCaseListSyntax.self), + .node(SwitchCaseSyntax.self), + .node(SwitchDefaultLabelSyntax.self), + .node(SwitchExprSyntax.self), + .node(TargetFunctionEntrySyntax.self), + .node(TernaryExprSyntax.self), + .node(ThrowStmtSyntax.self), + .node(TryExprSyntax.self), + .node(TupleExprElementListSyntax.self), + .node(TupleExprElementSyntax.self), + .node(TupleExprSyntax.self), + .node(TuplePatternElementListSyntax.self), + .node(TuplePatternElementSyntax.self), + .node(TuplePatternSyntax.self), + .node(TupleTypeElementListSyntax.self), + .node(TupleTypeElementSyntax.self), + .node(TupleTypeSyntax.self), + .node(TypeAnnotationSyntax.self), + .node(TypeEffectSpecifiersSyntax.self), + .node(TypeExprSyntax.self), + .node(TypeInheritanceClauseSyntax.self), + .node(TypeInitializerClauseSyntax.self), + .node(TypealiasDeclSyntax.self), + .node(UnavailableFromAsyncArgumentsSyntax.self), + .node(UnderscorePrivateAttributeArgumentsSyntax.self), + .node(UnexpectedNodesSyntax.self), + .node(UnresolvedAsExprSyntax.self), + .node(UnresolvedIsExprSyntax.self), + .node(UnresolvedPatternExprSyntax.self), + .node(UnresolvedTernaryExprSyntax.self), + .node(ValueBindingPatternSyntax.self), + .node(VariableDeclSyntax.self), + .node(VersionTupleSyntax.self), + .node(WhereClauseSyntax.self), + .node(WhileStmtSyntax.self), + .node(WildcardPatternSyntax.self), + .node(YieldExprListElementSyntax.self), + .node(YieldExprListSyntax.self), + .node(YieldListSyntax.self), .node(YieldStmtSyntax.self) ]) } diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift index 70db610e451..f185e513707 100644 --- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift +++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift @@ -14,8 +14,8 @@ public protocol SyntaxCollection: SyntaxProtocol, Sequence where Element: SyntaxProtocol { /// The number of elements, `present` or `missing`, in this collection. - var count: Int { - get + var count: Int { + get } } @@ -39,8 +39,8 @@ public struct AccessPathSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .accessPath else { - return nil + guard node.raw.kind == .accessPath else { + return nil } self._syntaxNode = node._syntaxNode } @@ -54,19 +54,19 @@ public struct AccessPathSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.accessPath, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.accessPath, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `AccessPathSyntax` by replacing the underlying layout with @@ -75,8 +75,7 @@ public struct AccessPathSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `AccessPathSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> AccessPathSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> AccessPathSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -115,8 +114,8 @@ public struct AccessPathSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> AccessPathSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -132,8 +131,8 @@ public struct AccessPathSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> AccessPathSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -249,8 +248,8 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .accessorList else { - return nil + guard node.raw.kind == .accessorList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -264,19 +263,19 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.accessorList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.accessorList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `AccessorListSyntax` by replacing the underlying layout with @@ -285,8 +284,7 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `AccessorListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> AccessorListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> AccessorListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -325,8 +323,8 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> AccessorListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -342,8 +340,8 @@ public struct AccessorListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> AccessorListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -459,8 +457,8 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .arrayElementList else { - return nil + guard node.raw.kind == .arrayElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -474,19 +472,19 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.arrayElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.arrayElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ArrayElementListSyntax` by replacing the underlying layout with @@ -495,8 +493,7 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ArrayElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ArrayElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ArrayElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -535,8 +532,8 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ArrayElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -552,8 +549,8 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ArrayElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -674,8 +671,8 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: AttributeSyntax) { @@ -689,18 +686,18 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { public init?(_ node: S) { if let node = node.as(AttributeSyntax.self) { self = .attribute(node) - return + return } if let node = node.as(IfConfigDeclSyntax.self) { self = .ifConfigDecl(node) - return + return } return nil } public static var structure: SyntaxNodeStructure { return .choices([ - .node(AttributeSyntax.self), + .node(AttributeSyntax.self), .node(IfConfigDeclSyntax.self)]) } } @@ -712,8 +709,8 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .attributeList else { - return nil + guard node.raw.kind == .attributeList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -727,19 +724,19 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `AttributeListSyntax` by replacing the underlying layout with @@ -748,8 +745,7 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `AttributeListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> AttributeListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> AttributeListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -788,8 +784,8 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> AttributeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -805,8 +801,8 @@ public struct AttributeListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> AttributeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -922,8 +918,8 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .availabilitySpecList else { - return nil + guard node.raw.kind == .availabilitySpecList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -937,19 +933,19 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `AvailabilitySpecListSyntax` by replacing the underlying layout with @@ -958,8 +954,7 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `AvailabilitySpecListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> AvailabilitySpecListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> AvailabilitySpecListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -998,8 +993,8 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> AvailabilitySpecListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -1015,8 +1010,8 @@ public struct AvailabilitySpecListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> AvailabilitySpecListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -1132,8 +1127,8 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax } public init?(_ node: S) { - guard node.raw.kind == .availabilityVersionRestrictionList else { - return nil + guard node.raw.kind == .availabilityVersionRestrictionList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1147,19 +1142,19 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `AvailabilityVersionRestrictionListSyntax` by replacing the underlying layout with @@ -1168,8 +1163,7 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `AvailabilityVersionRestrictionListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> AvailabilityVersionRestrictionListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> AvailabilityVersionRestrictionListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -1208,8 +1202,8 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax public func inserting(_ syntax: Element, at index: Int) -> AvailabilityVersionRestrictionListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -1225,8 +1219,8 @@ public struct AvailabilityVersionRestrictionListSyntax: SyntaxCollection, Syntax public func replacing(childAt index: Int, with syntax: Element) -> AvailabilityVersionRestrictionListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -1342,8 +1336,8 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .caseItemList else { - return nil + guard node.raw.kind == .caseItemList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1357,19 +1351,19 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.caseItemList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.caseItemList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `CaseItemListSyntax` by replacing the underlying layout with @@ -1378,8 +1372,7 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `CaseItemListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> CaseItemListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> CaseItemListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -1418,8 +1411,8 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> CaseItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -1435,8 +1428,8 @@ public struct CaseItemListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> CaseItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -1552,8 +1545,8 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .catchClauseList else { - return nil + guard node.raw.kind == .catchClauseList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1567,19 +1560,19 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `CatchClauseListSyntax` by replacing the underlying layout with @@ -1588,8 +1581,7 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `CatchClauseListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> CatchClauseListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> CatchClauseListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -1628,8 +1620,8 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> CatchClauseListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -1645,8 +1637,8 @@ public struct CatchClauseListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> CatchClauseListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -1762,8 +1754,8 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .catchItemList else { - return nil + guard node.raw.kind == .catchItemList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1777,19 +1769,19 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.catchItemList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.catchItemList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `CatchItemListSyntax` by replacing the underlying layout with @@ -1798,8 +1790,7 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `CatchItemListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> CatchItemListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> CatchItemListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -1838,8 +1829,8 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> CatchItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -1855,8 +1846,8 @@ public struct CatchItemListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> CatchItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -1972,8 +1963,8 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .closureCaptureItemList else { - return nil + guard node.raw.kind == .closureCaptureItemList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1987,19 +1978,19 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureCaptureItemList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureCaptureItemList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ClosureCaptureItemListSyntax` by replacing the underlying layout with @@ -2008,8 +1999,7 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ClosureCaptureItemListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ClosureCaptureItemListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ClosureCaptureItemListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -2048,8 +2038,8 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ClosureCaptureItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -2065,8 +2055,8 @@ public struct ClosureCaptureItemListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ClosureCaptureItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -2182,8 +2172,8 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .closureParamList else { - return nil + guard node.raw.kind == .closureParamList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2197,19 +2187,19 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureParamList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureParamList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ClosureParamListSyntax` by replacing the underlying layout with @@ -2218,8 +2208,7 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ClosureParamListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ClosureParamListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ClosureParamListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -2258,8 +2247,8 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ClosureParamListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -2275,8 +2264,8 @@ public struct ClosureParamListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ClosureParamListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -2392,8 +2381,8 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .closureParameterList else { - return nil + guard node.raw.kind == .closureParameterList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2407,19 +2396,19 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ClosureParameterListSyntax` by replacing the underlying layout with @@ -2428,8 +2417,7 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ClosureParameterListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ClosureParameterListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ClosureParameterListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -2468,8 +2456,8 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ClosureParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -2485,8 +2473,8 @@ public struct ClosureParameterListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ClosureParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -2602,8 +2590,8 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .codeBlockItemList else { - return nil + guard node.raw.kind == .codeBlockItemList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2617,19 +2605,19 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `CodeBlockItemListSyntax` by replacing the underlying layout with @@ -2638,8 +2626,7 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `CodeBlockItemListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> CodeBlockItemListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> CodeBlockItemListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -2678,8 +2665,8 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> CodeBlockItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -2695,8 +2682,8 @@ public struct CodeBlockItemListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> CodeBlockItemListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -2812,8 +2799,8 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable } public init?(_ node: S) { - guard node.raw.kind == .compositionTypeElementList else { - return nil + guard node.raw.kind == .compositionTypeElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2827,19 +2814,19 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.compositionTypeElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.compositionTypeElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `CompositionTypeElementListSyntax` by replacing the underlying layout with @@ -2848,8 +2835,7 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `CompositionTypeElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> CompositionTypeElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> CompositionTypeElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -2888,8 +2874,8 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable public func inserting(_ syntax: Element, at index: Int) -> CompositionTypeElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -2905,8 +2891,8 @@ public struct CompositionTypeElementListSyntax: SyntaxCollection, SyntaxHashable public func replacing(childAt index: Int, with syntax: Element) -> CompositionTypeElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -3022,8 +3008,8 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .conditionElementList else { - return nil + guard node.raw.kind == .conditionElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3037,19 +3023,19 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ConditionElementListSyntax` by replacing the underlying layout with @@ -3058,8 +3044,7 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ConditionElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ConditionElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ConditionElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -3098,8 +3083,8 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ConditionElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -3115,8 +3100,8 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ConditionElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -3232,8 +3217,8 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .declNameArgumentList else { - return nil + guard node.raw.kind == .declNameArgumentList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3247,19 +3232,19 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `DeclNameArgumentListSyntax` by replacing the underlying layout with @@ -3268,8 +3253,7 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `DeclNameArgumentListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> DeclNameArgumentListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> DeclNameArgumentListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -3308,8 +3292,8 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> DeclNameArgumentListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -3325,8 +3309,8 @@ public struct DeclNameArgumentListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> DeclNameArgumentListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -3442,8 +3426,8 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .designatedTypeList else { - return nil + guard node.raw.kind == .designatedTypeList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3457,19 +3441,19 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `DesignatedTypeListSyntax` by replacing the underlying layout with @@ -3478,8 +3462,7 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `DesignatedTypeListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> DesignatedTypeListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> DesignatedTypeListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -3518,8 +3501,8 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> DesignatedTypeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -3535,8 +3518,8 @@ public struct DesignatedTypeListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> DesignatedTypeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -3652,8 +3635,8 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .dictionaryElementList else { - return nil + guard node.raw.kind == .dictionaryElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3667,19 +3650,19 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.dictionaryElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.dictionaryElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `DictionaryElementListSyntax` by replacing the underlying layout with @@ -3688,8 +3671,7 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `DictionaryElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> DictionaryElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> DictionaryElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -3728,8 +3710,8 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> DictionaryElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -3745,8 +3727,8 @@ public struct DictionaryElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> DictionaryElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -3862,8 +3844,8 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable } public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParamList else { - return nil + guard node.raw.kind == .differentiabilityParamList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3877,19 +3859,19 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `DifferentiabilityParamListSyntax` by replacing the underlying layout with @@ -3898,8 +3880,7 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `DifferentiabilityParamListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> DifferentiabilityParamListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> DifferentiabilityParamListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -3938,8 +3919,8 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable public func inserting(_ syntax: Element, at index: Int) -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -3955,8 +3936,8 @@ public struct DifferentiabilityParamListSyntax: SyntaxCollection, SyntaxHashable public func replacing(childAt index: Int, with syntax: Element) -> DifferentiabilityParamListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -4069,8 +4050,8 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas } public init?(_ node: S) { - guard node.raw.kind == .documentationAttributeArguments else { - return nil + guard node.raw.kind == .documentationAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4084,19 +4065,19 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.documentationAttributeArguments, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.documentationAttributeArguments, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `DocumentationAttributeArgumentsSyntax` by replacing the underlying layout with @@ -4105,8 +4086,7 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `DocumentationAttributeArgumentsSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> DocumentationAttributeArgumentsSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> DocumentationAttributeArgumentsSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -4145,8 +4125,8 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas public func inserting(_ syntax: Element, at index: Int) -> DocumentationAttributeArgumentsSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -4162,8 +4142,8 @@ public struct DocumentationAttributeArgumentsSyntax: SyntaxCollection, SyntaxHas public func replacing(childAt index: Int, with syntax: Element) -> DocumentationAttributeArgumentsSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -4276,8 +4256,8 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .effectsArguments else { - return nil + guard node.raw.kind == .effectsArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4291,19 +4271,19 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.effectsArguments, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.effectsArguments, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `EffectsArgumentsSyntax` by replacing the underlying layout with @@ -4312,8 +4292,7 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `EffectsArgumentsSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> EffectsArgumentsSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> EffectsArgumentsSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -4352,8 +4331,8 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> EffectsArgumentsSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -4369,8 +4348,8 @@ public struct EffectsArgumentsSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> EffectsArgumentsSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -4483,8 +4462,8 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .enumCaseElementList else { - return nil + guard node.raw.kind == .enumCaseElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4498,19 +4477,19 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `EnumCaseElementListSyntax` by replacing the underlying layout with @@ -4519,8 +4498,7 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `EnumCaseElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> EnumCaseElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> EnumCaseElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -4559,8 +4537,8 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> EnumCaseElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -4576,8 +4554,8 @@ public struct EnumCaseElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> EnumCaseElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -4693,8 +4671,8 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .enumCaseParameterList else { - return nil + guard node.raw.kind == .enumCaseParameterList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4708,19 +4686,19 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `EnumCaseParameterListSyntax` by replacing the underlying layout with @@ -4729,8 +4707,7 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `EnumCaseParameterListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> EnumCaseParameterListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> EnumCaseParameterListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -4769,8 +4746,8 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> EnumCaseParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -4786,8 +4763,8 @@ public struct EnumCaseParameterListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> EnumCaseParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -4900,8 +4877,8 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .exprList else { - return nil + guard node.raw.kind == .exprList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4915,19 +4892,19 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.exprList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.exprList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ExprListSyntax` by replacing the underlying layout with @@ -4936,8 +4913,7 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ExprListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ExprListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ExprListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -4976,8 +4952,8 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ExprListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -4993,8 +4969,8 @@ public struct ExprListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ExprListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -5110,8 +5086,8 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .functionParameterList else { - return nil + guard node.raw.kind == .functionParameterList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5125,19 +5101,19 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.functionParameterList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.functionParameterList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `FunctionParameterListSyntax` by replacing the underlying layout with @@ -5146,8 +5122,7 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `FunctionParameterListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> FunctionParameterListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> FunctionParameterListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -5186,8 +5161,8 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> FunctionParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -5203,8 +5178,8 @@ public struct FunctionParameterListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> FunctionParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -5320,8 +5295,8 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .genericArgumentList else { - return nil + guard node.raw.kind == .genericArgumentList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5335,19 +5310,19 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.genericArgumentList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.genericArgumentList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `GenericArgumentListSyntax` by replacing the underlying layout with @@ -5356,8 +5331,7 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `GenericArgumentListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> GenericArgumentListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> GenericArgumentListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -5396,8 +5370,8 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> GenericArgumentListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -5413,8 +5387,8 @@ public struct GenericArgumentListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> GenericArgumentListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -5530,8 +5504,8 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .genericParameterList else { - return nil + guard node.raw.kind == .genericParameterList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5545,19 +5519,19 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.genericParameterList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.genericParameterList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `GenericParameterListSyntax` by replacing the underlying layout with @@ -5566,8 +5540,7 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `GenericParameterListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> GenericParameterListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> GenericParameterListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -5606,8 +5579,8 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> GenericParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -5623,8 +5596,8 @@ public struct GenericParameterListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> GenericParameterListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -5740,8 +5713,8 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .genericRequirementList else { - return nil + guard node.raw.kind == .genericRequirementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5755,19 +5728,19 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.genericRequirementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.genericRequirementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `GenericRequirementListSyntax` by replacing the underlying layout with @@ -5776,8 +5749,7 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `GenericRequirementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> GenericRequirementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> GenericRequirementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -5816,8 +5788,8 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> GenericRequirementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -5833,8 +5805,8 @@ public struct GenericRequirementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> GenericRequirementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -5950,8 +5922,8 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .ifConfigClauseList else { - return nil + guard node.raw.kind == .ifConfigClauseList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5965,19 +5937,19 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.ifConfigClauseList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.ifConfigClauseList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `IfConfigClauseListSyntax` by replacing the underlying layout with @@ -5986,8 +5958,7 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `IfConfigClauseListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> IfConfigClauseListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> IfConfigClauseListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -6026,8 +5997,8 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> IfConfigClauseListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -6043,8 +6014,8 @@ public struct IfConfigClauseListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> IfConfigClauseListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -6160,8 +6131,8 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .inheritedTypeList else { - return nil + guard node.raw.kind == .inheritedTypeList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6175,19 +6146,19 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.inheritedTypeList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.inheritedTypeList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `InheritedTypeListSyntax` by replacing the underlying layout with @@ -6196,8 +6167,7 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `InheritedTypeListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> InheritedTypeListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> InheritedTypeListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -6236,8 +6206,8 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> InheritedTypeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -6253,8 +6223,8 @@ public struct InheritedTypeListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> InheritedTypeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -6370,8 +6340,8 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .keyPathComponentList else { - return nil + guard node.raw.kind == .keyPathComponentList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6385,19 +6355,19 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.keyPathComponentList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.keyPathComponentList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `KeyPathComponentListSyntax` by replacing the underlying layout with @@ -6406,8 +6376,7 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `KeyPathComponentListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> KeyPathComponentListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> KeyPathComponentListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -6446,8 +6415,8 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> KeyPathComponentListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -6463,8 +6432,8 @@ public struct KeyPathComponentListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> KeyPathComponentListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -6580,8 +6549,8 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .memberDeclList else { - return nil + guard node.raw.kind == .memberDeclList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6595,19 +6564,19 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.memberDeclList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.memberDeclList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `MemberDeclListSyntax` by replacing the underlying layout with @@ -6616,8 +6585,7 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `MemberDeclListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> MemberDeclListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> MemberDeclListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -6656,8 +6624,8 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> MemberDeclListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -6673,8 +6641,8 @@ public struct MemberDeclListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> MemberDeclListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -6790,8 +6758,8 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .modifierList else { - return nil + guard node.raw.kind == .modifierList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6805,19 +6773,19 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ModifierListSyntax` by replacing the underlying layout with @@ -6826,8 +6794,7 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ModifierListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ModifierListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ModifierListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -6866,8 +6833,8 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ModifierListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -6883,8 +6850,8 @@ public struct ModifierListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ModifierListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -7000,8 +6967,8 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax } public init?(_ node: S) { - guard node.raw.kind == .multipleTrailingClosureElementList else { - return nil + guard node.raw.kind == .multipleTrailingClosureElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7015,19 +6982,19 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `MultipleTrailingClosureElementListSyntax` by replacing the underlying layout with @@ -7036,8 +7003,7 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `MultipleTrailingClosureElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> MultipleTrailingClosureElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> MultipleTrailingClosureElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -7076,8 +7042,8 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax public func inserting(_ syntax: Element, at index: Int) -> MultipleTrailingClosureElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -7093,8 +7059,8 @@ public struct MultipleTrailingClosureElementListSyntax: SyntaxCollection, Syntax public func replacing(childAt index: Int, with syntax: Element) -> MultipleTrailingClosureElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -7210,8 +7176,8 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .objCSelector else { - return nil + guard node.raw.kind == .objCSelector else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7225,19 +7191,19 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.objCSelector, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.objCSelector, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `ObjCSelectorSyntax` by replacing the underlying layout with @@ -7246,8 +7212,7 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `ObjCSelectorSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> ObjCSelectorSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> ObjCSelectorSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -7286,8 +7251,8 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> ObjCSelectorSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -7303,8 +7268,8 @@ public struct ObjCSelectorSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> ObjCSelectorSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -7420,8 +7385,8 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .patternBindingList else { - return nil + guard node.raw.kind == .patternBindingList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7435,19 +7400,19 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.patternBindingList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.patternBindingList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `PatternBindingListSyntax` by replacing the underlying layout with @@ -7456,8 +7421,7 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `PatternBindingListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> PatternBindingListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> PatternBindingListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -7496,8 +7460,8 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> PatternBindingListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -7513,8 +7477,8 @@ public struct PatternBindingListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> PatternBindingListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -7638,8 +7602,8 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: PrecedenceGroupRelationSyntax) { @@ -7657,23 +7621,23 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab public init?(_ node: S) { if let node = node.as(PrecedenceGroupRelationSyntax.self) { self = .precedenceGroupRelation(node) - return + return } if let node = node.as(PrecedenceGroupAssignmentSyntax.self) { self = .precedenceGroupAssignment(node) - return + return } if let node = node.as(PrecedenceGroupAssociativitySyntax.self) { self = .precedenceGroupAssociativity(node) - return + return } return nil } public static var structure: SyntaxNodeStructure { return .choices([ - .node(PrecedenceGroupRelationSyntax.self), - .node(PrecedenceGroupAssignmentSyntax.self), + .node(PrecedenceGroupRelationSyntax.self), + .node(PrecedenceGroupAssignmentSyntax.self), .node(PrecedenceGroupAssociativitySyntax.self)]) } } @@ -7685,8 +7649,8 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab } public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAttributeList else { - return nil + guard node.raw.kind == .precedenceGroupAttributeList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7700,19 +7664,19 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupAttributeList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupAttributeList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `PrecedenceGroupAttributeListSyntax` by replacing the underlying layout with @@ -7721,8 +7685,7 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `PrecedenceGroupAttributeListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> PrecedenceGroupAttributeListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> PrecedenceGroupAttributeListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -7761,8 +7724,8 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab public func inserting(_ syntax: Element, at index: Int) -> PrecedenceGroupAttributeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -7778,8 +7741,8 @@ public struct PrecedenceGroupAttributeListSyntax: SyntaxCollection, SyntaxHashab public func replacing(childAt index: Int, with syntax: Element) -> PrecedenceGroupAttributeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -7895,8 +7858,8 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupNameList else { - return nil + guard node.raw.kind == .precedenceGroupNameList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7910,19 +7873,19 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `PrecedenceGroupNameListSyntax` by replacing the underlying layout with @@ -7931,8 +7894,7 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `PrecedenceGroupNameListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> PrecedenceGroupNameListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> PrecedenceGroupNameListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -7971,8 +7933,8 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> PrecedenceGroupNameListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -7988,8 +7950,8 @@ public struct PrecedenceGroupNameListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> PrecedenceGroupNameListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -8105,8 +8067,8 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable } public init?(_ node: S) { - guard node.raw.kind == .primaryAssociatedTypeList else { - return nil + guard node.raw.kind == .primaryAssociatedTypeList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8120,19 +8082,19 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.primaryAssociatedTypeList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.primaryAssociatedTypeList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `PrimaryAssociatedTypeListSyntax` by replacing the underlying layout with @@ -8141,8 +8103,7 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `PrimaryAssociatedTypeListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> PrimaryAssociatedTypeListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> PrimaryAssociatedTypeListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -8181,8 +8142,8 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable public func inserting(_ syntax: Element, at index: Int) -> PrimaryAssociatedTypeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -8198,8 +8159,8 @@ public struct PrimaryAssociatedTypeListSyntax: SyntaxCollection, SyntaxHashable public func replacing(childAt index: Int, with syntax: Element) -> PrimaryAssociatedTypeListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -8323,8 +8284,8 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: LabeledSpecializeEntrySyntax) { @@ -8346,28 +8307,28 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl public init?(_ node: S) { if let node = node.as(LabeledSpecializeEntrySyntax.self) { self = .labeledSpecializeEntry(node) - return + return } if let node = node.as(AvailabilityEntrySyntax.self) { self = .availabilityEntry(node) - return + return } if let node = node.as(TargetFunctionEntrySyntax.self) { self = .targetFunctionEntry(node) - return + return } if let node = node.as(GenericWhereClauseSyntax.self) { self = .genericWhereClause(node) - return + return } return nil } public static var structure: SyntaxNodeStructure { return .choices([ - .node(LabeledSpecializeEntrySyntax.self), - .node(AvailabilityEntrySyntax.self), - .node(TargetFunctionEntrySyntax.self), + .node(LabeledSpecializeEntrySyntax.self), + .node(AvailabilityEntrySyntax.self), + .node(TargetFunctionEntrySyntax.self), .node(GenericWhereClauseSyntax.self) ]) } @@ -8380,8 +8341,8 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl } public init?(_ node: S) { - guard node.raw.kind == .specializeAttributeSpecList else { - return nil + guard node.raw.kind == .specializeAttributeSpecList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8395,19 +8356,19 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.specializeAttributeSpecList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.specializeAttributeSpecList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `SpecializeAttributeSpecListSyntax` by replacing the underlying layout with @@ -8416,8 +8377,7 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `SpecializeAttributeSpecListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> SpecializeAttributeSpecListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> SpecializeAttributeSpecListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -8456,8 +8416,8 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl public func inserting(_ syntax: Element, at index: Int) -> SpecializeAttributeSpecListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -8473,8 +8433,8 @@ public struct SpecializeAttributeSpecListSyntax: SyntaxCollection, SyntaxHashabl public func replacing(childAt index: Int, with syntax: Element) -> SpecializeAttributeSpecListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -8595,8 +8555,8 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: StringSegmentSyntax) { @@ -8610,18 +8570,18 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { public init?(_ node: S) { if let node = node.as(StringSegmentSyntax.self) { self = .stringSegment(node) - return + return } if let node = node.as(ExpressionSegmentSyntax.self) { self = .expressionSegment(node) - return + return } return nil } public static var structure: SyntaxNodeStructure { return .choices([ - .node(StringSegmentSyntax.self), + .node(StringSegmentSyntax.self), .node(ExpressionSegmentSyntax.self)]) } } @@ -8633,8 +8593,8 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .stringLiteralSegments else { - return nil + guard node.raw.kind == .stringLiteralSegments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8648,19 +8608,19 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralSegments, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralSegments, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `StringLiteralSegmentsSyntax` by replacing the underlying layout with @@ -8669,8 +8629,7 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `StringLiteralSegmentsSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> StringLiteralSegmentsSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> StringLiteralSegmentsSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -8709,8 +8668,8 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> StringLiteralSegmentsSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -8726,8 +8685,8 @@ public struct StringLiteralSegmentsSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> StringLiteralSegmentsSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -8848,8 +8807,8 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: SwitchCaseSyntax) { @@ -8863,18 +8822,18 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { public init?(_ node: S) { if let node = node.as(SwitchCaseSyntax.self) { self = .switchCase(node) - return + return } if let node = node.as(IfConfigDeclSyntax.self) { self = .ifConfigDecl(node) - return + return } return nil } public static var structure: SyntaxNodeStructure { return .choices([ - .node(SwitchCaseSyntax.self), + .node(SwitchCaseSyntax.self), .node(IfConfigDeclSyntax.self)]) } } @@ -8886,8 +8845,8 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .switchCaseList else { - return nil + guard node.raw.kind == .switchCaseList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8901,19 +8860,19 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `SwitchCaseListSyntax` by replacing the underlying layout with @@ -8922,8 +8881,7 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `SwitchCaseListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> SwitchCaseListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> SwitchCaseListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -8962,8 +8920,8 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> SwitchCaseListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -8979,8 +8937,8 @@ public struct SwitchCaseListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> SwitchCaseListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -9096,8 +9054,8 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .tupleExprElementList else { - return nil + guard node.raw.kind == .tupleExprElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9111,19 +9069,19 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `TupleExprElementListSyntax` by replacing the underlying layout with @@ -9132,8 +9090,7 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `TupleExprElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> TupleExprElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> TupleExprElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -9172,8 +9129,8 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> TupleExprElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -9189,8 +9146,8 @@ public struct TupleExprElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> TupleExprElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -9306,8 +9263,8 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .tuplePatternElementList else { - return nil + guard node.raw.kind == .tuplePatternElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9321,19 +9278,19 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.tuplePatternElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.tuplePatternElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `TuplePatternElementListSyntax` by replacing the underlying layout with @@ -9342,8 +9299,7 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `TuplePatternElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> TuplePatternElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> TuplePatternElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -9382,8 +9338,8 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> TuplePatternElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -9399,8 +9355,8 @@ public struct TuplePatternElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> TuplePatternElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -9516,8 +9472,8 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .tupleTypeElementList else { - return nil + guard node.raw.kind == .tupleTypeElementList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9531,19 +9487,19 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `TupleTypeElementListSyntax` by replacing the underlying layout with @@ -9552,8 +9508,7 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `TupleTypeElementListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> TupleTypeElementListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> TupleTypeElementListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -9592,8 +9547,8 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> TupleTypeElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -9609,8 +9564,8 @@ public struct TupleTypeElementListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> TupleTypeElementListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -9723,8 +9678,8 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .unexpectedNodes else { - return nil + guard node.raw.kind == .unexpectedNodes else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9738,19 +9693,19 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.unexpectedNodes, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.unexpectedNodes, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `UnexpectedNodesSyntax` by replacing the underlying layout with @@ -9759,8 +9714,7 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `UnexpectedNodesSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> UnexpectedNodesSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> UnexpectedNodesSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -9799,8 +9753,8 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> UnexpectedNodesSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -9816,8 +9770,8 @@ public struct UnexpectedNodesSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> UnexpectedNodesSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } @@ -9933,8 +9887,8 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable { } public init?(_ node: S) { - guard node.raw.kind == .yieldExprList else { - return nil + guard node.raw.kind == .yieldExprList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9948,19 +9902,19 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable { } public init(_ children: [Element]) { - let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in - let raw = RawSyntax.makeLayout(kind: SyntaxKind.yieldExprList, - from: children.map { - $0.raw - }, arena: arena) + let data: SyntaxData = withExtendedLifetime(SyntaxArena()) { arena in + let raw = RawSyntax.makeLayout(kind: SyntaxKind.yieldExprList, + from: children.map { + $0.raw + }, arena: arena) return SyntaxData.forRoot(raw) } self.init(data) } /// The number of elements, `present` or `missing`, in this collection. - public var count: Int { - return layoutView.children.count + public var count: Int { + return layoutView.children.count } /// Creates a new `YieldExprListSyntax` by replacing the underlying layout with @@ -9969,8 +9923,7 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable { /// - Parameter layout: The new list of raw syntax nodes underlying this /// collection. /// - Returns: A new `YieldExprListSyntax` with the new layout underlying it. - internal func replacingLayout( - _ layout: [RawSyntax?]) -> YieldExprListSyntax { + internal func replacingLayout(_ layout: [RawSyntax?]) -> YieldExprListSyntax { let arena = SyntaxArena() let newRaw = layoutView.replacingLayout(with: layout, arena: arena) let newData = data.replacingSelf(newRaw, arena: arena) @@ -10009,8 +9962,8 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable { public func inserting(_ syntax: Element, at index: Int) -> YieldExprListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid insertion index (0 to 1 past the end) - precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), - "inserting node at invalid index \(index)") + precondition((newLayout.startIndex ... newLayout.endIndex).contains(index), + "inserting node at invalid index \(index)") newLayout.insert(syntax.raw, at: index) return replacingLayout(newLayout) } @@ -10026,8 +9979,8 @@ public struct YieldExprListSyntax: SyntaxCollection, SyntaxHashable { public func replacing(childAt index: Int, with syntax: Element) -> YieldExprListSyntax { var newLayout = layoutView.formLayoutArray() /// Make sure the index is a valid index for replacing - precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), - "replacing node at invalid index \(index)") + precondition((newLayout.startIndex ..< newLayout.endIndex).contains(index), + "replacing node at invalid index \(index)") newLayout[index] = syntax.raw return replacingLayout(newLayout) } diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift index c70f90f24a7..3fdb902fd64 100644 --- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift +++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift @@ -1980,11 +1980,11 @@ open class SyntaxRewriter { let node = AccessPathComponentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -1994,11 +1994,11 @@ open class SyntaxRewriter { let node = AccessPathSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2008,11 +2008,11 @@ open class SyntaxRewriter { let node = AccessorBlockSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2022,11 +2022,11 @@ open class SyntaxRewriter { let node = AccessorDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2036,11 +2036,11 @@ open class SyntaxRewriter { let node = AccessorEffectSpecifiersSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2050,11 +2050,11 @@ open class SyntaxRewriter { let node = AccessorListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2064,11 +2064,11 @@ open class SyntaxRewriter { let node = AccessorParameterSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2078,11 +2078,11 @@ open class SyntaxRewriter { let node = ActorDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2092,11 +2092,11 @@ open class SyntaxRewriter { let node = ArrayElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2106,11 +2106,11 @@ open class SyntaxRewriter { let node = ArrayElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2120,11 +2120,11 @@ open class SyntaxRewriter { let node = ArrayExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2134,11 +2134,11 @@ open class SyntaxRewriter { let node = ArrayTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2148,11 +2148,11 @@ open class SyntaxRewriter { let node = ArrowExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2162,11 +2162,11 @@ open class SyntaxRewriter { let node = AsExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2176,11 +2176,11 @@ open class SyntaxRewriter { let node = AssignmentExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2190,11 +2190,11 @@ open class SyntaxRewriter { let node = AssociatedtypeDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2204,11 +2204,11 @@ open class SyntaxRewriter { let node = AttributeListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2218,11 +2218,11 @@ open class SyntaxRewriter { let node = AttributeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2232,11 +2232,11 @@ open class SyntaxRewriter { let node = AttributedTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2246,11 +2246,11 @@ open class SyntaxRewriter { let node = AvailabilityArgumentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2260,11 +2260,11 @@ open class SyntaxRewriter { let node = AvailabilityConditionSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2274,11 +2274,11 @@ open class SyntaxRewriter { let node = AvailabilityEntrySyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2288,11 +2288,11 @@ open class SyntaxRewriter { let node = AvailabilityLabeledArgumentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2302,11 +2302,11 @@ open class SyntaxRewriter { let node = AvailabilitySpecListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2316,11 +2316,11 @@ open class SyntaxRewriter { let node = AvailabilityVersionRestrictionListEntrySyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2330,11 +2330,11 @@ open class SyntaxRewriter { let node = AvailabilityVersionRestrictionListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2344,11 +2344,11 @@ open class SyntaxRewriter { let node = AvailabilityVersionRestrictionSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2358,11 +2358,11 @@ open class SyntaxRewriter { let node = AwaitExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2372,11 +2372,11 @@ open class SyntaxRewriter { let node = BackDeployedAttributeSpecListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2386,11 +2386,11 @@ open class SyntaxRewriter { let node = BinaryOperatorExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2400,11 +2400,11 @@ open class SyntaxRewriter { let node = BooleanLiteralExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2414,11 +2414,11 @@ open class SyntaxRewriter { let node = BorrowExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2428,11 +2428,11 @@ open class SyntaxRewriter { let node = BreakStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2442,11 +2442,11 @@ open class SyntaxRewriter { let node = CaseItemListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2456,11 +2456,11 @@ open class SyntaxRewriter { let node = CaseItemSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2470,11 +2470,11 @@ open class SyntaxRewriter { let node = CatchClauseListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2484,11 +2484,11 @@ open class SyntaxRewriter { let node = CatchClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2498,11 +2498,11 @@ open class SyntaxRewriter { let node = CatchItemListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2512,11 +2512,11 @@ open class SyntaxRewriter { let node = CatchItemSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2526,11 +2526,11 @@ open class SyntaxRewriter { let node = ClassDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2540,11 +2540,11 @@ open class SyntaxRewriter { let node = ClassRestrictionTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2554,11 +2554,11 @@ open class SyntaxRewriter { let node = ClosureCaptureItemListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2568,11 +2568,11 @@ open class SyntaxRewriter { let node = ClosureCaptureItemSpecifierSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2582,11 +2582,11 @@ open class SyntaxRewriter { let node = ClosureCaptureItemSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2596,11 +2596,11 @@ open class SyntaxRewriter { let node = ClosureCaptureSignatureSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2610,11 +2610,11 @@ open class SyntaxRewriter { let node = ClosureExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2624,11 +2624,11 @@ open class SyntaxRewriter { let node = ClosureParamListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2638,11 +2638,11 @@ open class SyntaxRewriter { let node = ClosureParamSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2652,11 +2652,11 @@ open class SyntaxRewriter { let node = ClosureParameterClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2666,11 +2666,11 @@ open class SyntaxRewriter { let node = ClosureParameterListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2680,11 +2680,11 @@ open class SyntaxRewriter { let node = ClosureParameterSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2694,11 +2694,11 @@ open class SyntaxRewriter { let node = ClosureSignatureSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2708,11 +2708,11 @@ open class SyntaxRewriter { let node = CodeBlockItemListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2722,11 +2722,11 @@ open class SyntaxRewriter { let node = CodeBlockItemSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2736,11 +2736,11 @@ open class SyntaxRewriter { let node = CodeBlockSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2750,11 +2750,11 @@ open class SyntaxRewriter { let node = CompositionTypeElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2764,11 +2764,11 @@ open class SyntaxRewriter { let node = CompositionTypeElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2778,11 +2778,11 @@ open class SyntaxRewriter { let node = CompositionTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2792,11 +2792,11 @@ open class SyntaxRewriter { let node = ConditionElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2806,11 +2806,11 @@ open class SyntaxRewriter { let node = ConditionElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2820,11 +2820,11 @@ open class SyntaxRewriter { let node = ConformanceRequirementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2834,11 +2834,11 @@ open class SyntaxRewriter { let node = ConstrainedSugarTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2848,11 +2848,11 @@ open class SyntaxRewriter { let node = ContinueStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2862,11 +2862,11 @@ open class SyntaxRewriter { let node = ConventionAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2876,11 +2876,11 @@ open class SyntaxRewriter { let node = ConventionWitnessMethodAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2890,11 +2890,11 @@ open class SyntaxRewriter { let node = DeclModifierDetailSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2904,11 +2904,11 @@ open class SyntaxRewriter { let node = DeclModifierSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2918,11 +2918,11 @@ open class SyntaxRewriter { let node = DeclNameArgumentListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2932,11 +2932,11 @@ open class SyntaxRewriter { let node = DeclNameArgumentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2946,11 +2946,11 @@ open class SyntaxRewriter { let node = DeclNameArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2960,11 +2960,11 @@ open class SyntaxRewriter { let node = DeclNameSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2974,11 +2974,11 @@ open class SyntaxRewriter { let node = DeferStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -2988,11 +2988,11 @@ open class SyntaxRewriter { let node = DeinitializerDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3002,11 +3002,11 @@ open class SyntaxRewriter { let node = DerivativeRegistrationAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3016,11 +3016,11 @@ open class SyntaxRewriter { let node = DesignatedTypeElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3030,11 +3030,11 @@ open class SyntaxRewriter { let node = DesignatedTypeListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3044,11 +3044,11 @@ open class SyntaxRewriter { let node = DictionaryElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3058,11 +3058,11 @@ open class SyntaxRewriter { let node = DictionaryElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3072,11 +3072,11 @@ open class SyntaxRewriter { let node = DictionaryExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3086,11 +3086,11 @@ open class SyntaxRewriter { let node = DictionaryTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3100,11 +3100,11 @@ open class SyntaxRewriter { let node = DifferentiabilityParamListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3114,11 +3114,11 @@ open class SyntaxRewriter { let node = DifferentiabilityParamSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3128,11 +3128,11 @@ open class SyntaxRewriter { let node = DifferentiabilityParamsClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3142,11 +3142,11 @@ open class SyntaxRewriter { let node = DifferentiabilityParamsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3156,11 +3156,11 @@ open class SyntaxRewriter { let node = DifferentiableAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3170,11 +3170,11 @@ open class SyntaxRewriter { let node = DiscardAssignmentExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3184,11 +3184,11 @@ open class SyntaxRewriter { let node = DoStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3198,11 +3198,11 @@ open class SyntaxRewriter { let node = DocumentationAttributeArgumentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3212,11 +3212,11 @@ open class SyntaxRewriter { let node = DocumentationAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3226,11 +3226,11 @@ open class SyntaxRewriter { let node = DynamicReplacementArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3240,11 +3240,11 @@ open class SyntaxRewriter { let node = EditorPlaceholderDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3254,11 +3254,11 @@ open class SyntaxRewriter { let node = EditorPlaceholderExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3268,11 +3268,11 @@ open class SyntaxRewriter { let node = EffectsArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3282,11 +3282,11 @@ open class SyntaxRewriter { let node = EnumCaseDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3296,11 +3296,11 @@ open class SyntaxRewriter { let node = EnumCaseElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3310,11 +3310,11 @@ open class SyntaxRewriter { let node = EnumCaseElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3324,11 +3324,11 @@ open class SyntaxRewriter { let node = EnumCaseParameterClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3338,11 +3338,11 @@ open class SyntaxRewriter { let node = EnumCaseParameterListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3352,11 +3352,11 @@ open class SyntaxRewriter { let node = EnumCaseParameterSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3366,11 +3366,11 @@ open class SyntaxRewriter { let node = EnumDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3380,11 +3380,11 @@ open class SyntaxRewriter { let node = ExposeAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3394,11 +3394,11 @@ open class SyntaxRewriter { let node = ExprListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3408,11 +3408,11 @@ open class SyntaxRewriter { let node = ExpressionPatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3422,11 +3422,11 @@ open class SyntaxRewriter { let node = ExpressionSegmentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3436,11 +3436,11 @@ open class SyntaxRewriter { let node = ExpressionStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3450,11 +3450,11 @@ open class SyntaxRewriter { let node = ExtensionDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3464,11 +3464,11 @@ open class SyntaxRewriter { let node = FallthroughStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3478,11 +3478,11 @@ open class SyntaxRewriter { let node = FloatLiteralExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3492,11 +3492,11 @@ open class SyntaxRewriter { let node = ForInStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3506,11 +3506,11 @@ open class SyntaxRewriter { let node = ForcedValueExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3520,11 +3520,11 @@ open class SyntaxRewriter { let node = ForgetStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3534,11 +3534,11 @@ open class SyntaxRewriter { let node = FunctionCallExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3548,11 +3548,11 @@ open class SyntaxRewriter { let node = FunctionDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3562,11 +3562,11 @@ open class SyntaxRewriter { let node = FunctionEffectSpecifiersSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3576,11 +3576,11 @@ open class SyntaxRewriter { let node = FunctionParameterListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3590,11 +3590,11 @@ open class SyntaxRewriter { let node = FunctionParameterSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3604,11 +3604,11 @@ open class SyntaxRewriter { let node = FunctionSignatureSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3618,11 +3618,11 @@ open class SyntaxRewriter { let node = FunctionTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3632,11 +3632,11 @@ open class SyntaxRewriter { let node = GenericArgumentClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3646,11 +3646,11 @@ open class SyntaxRewriter { let node = GenericArgumentListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3660,11 +3660,11 @@ open class SyntaxRewriter { let node = GenericArgumentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3674,11 +3674,11 @@ open class SyntaxRewriter { let node = GenericParameterClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3688,11 +3688,11 @@ open class SyntaxRewriter { let node = GenericParameterListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3702,11 +3702,11 @@ open class SyntaxRewriter { let node = GenericParameterSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3716,11 +3716,11 @@ open class SyntaxRewriter { let node = GenericRequirementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3730,11 +3730,11 @@ open class SyntaxRewriter { let node = GenericRequirementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3744,11 +3744,11 @@ open class SyntaxRewriter { let node = GenericWhereClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3758,11 +3758,11 @@ open class SyntaxRewriter { let node = GuardStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3772,11 +3772,11 @@ open class SyntaxRewriter { let node = IdentifierExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3786,11 +3786,11 @@ open class SyntaxRewriter { let node = IdentifierPatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3800,11 +3800,11 @@ open class SyntaxRewriter { let node = IfConfigClauseListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3814,11 +3814,11 @@ open class SyntaxRewriter { let node = IfConfigClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3828,11 +3828,11 @@ open class SyntaxRewriter { let node = IfConfigDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3842,11 +3842,11 @@ open class SyntaxRewriter { let node = IfExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3856,11 +3856,11 @@ open class SyntaxRewriter { let node = ImplementsAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3870,11 +3870,11 @@ open class SyntaxRewriter { let node = ImplicitlyUnwrappedOptionalTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3884,11 +3884,11 @@ open class SyntaxRewriter { let node = ImportDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3898,11 +3898,11 @@ open class SyntaxRewriter { let node = InOutExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3912,11 +3912,11 @@ open class SyntaxRewriter { let node = InfixOperatorExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3926,11 +3926,11 @@ open class SyntaxRewriter { let node = InheritedTypeListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3940,11 +3940,11 @@ open class SyntaxRewriter { let node = InheritedTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3954,11 +3954,11 @@ open class SyntaxRewriter { let node = InitializerClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3968,11 +3968,11 @@ open class SyntaxRewriter { let node = InitializerDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3982,11 +3982,11 @@ open class SyntaxRewriter { let node = IntegerLiteralExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -3996,11 +3996,11 @@ open class SyntaxRewriter { let node = IsExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4010,11 +4010,11 @@ open class SyntaxRewriter { let node = IsTypePatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4024,11 +4024,11 @@ open class SyntaxRewriter { let node = KeyPathComponentListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4038,11 +4038,11 @@ open class SyntaxRewriter { let node = KeyPathComponentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4052,11 +4052,11 @@ open class SyntaxRewriter { let node = KeyPathExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4066,11 +4066,11 @@ open class SyntaxRewriter { let node = KeyPathOptionalComponentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4080,11 +4080,11 @@ open class SyntaxRewriter { let node = KeyPathPropertyComponentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4094,11 +4094,11 @@ open class SyntaxRewriter { let node = KeyPathSubscriptComponentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4108,11 +4108,11 @@ open class SyntaxRewriter { let node = LabeledSpecializeEntrySyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4122,11 +4122,11 @@ open class SyntaxRewriter { let node = LabeledStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4136,11 +4136,11 @@ open class SyntaxRewriter { let node = LayoutRequirementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4150,11 +4150,11 @@ open class SyntaxRewriter { let node = MacroDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4164,11 +4164,11 @@ open class SyntaxRewriter { let node = MacroExpansionDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4178,11 +4178,11 @@ open class SyntaxRewriter { let node = MacroExpansionExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4192,11 +4192,11 @@ open class SyntaxRewriter { let node = MatchingPatternConditionSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4206,11 +4206,11 @@ open class SyntaxRewriter { let node = MemberAccessExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4220,11 +4220,11 @@ open class SyntaxRewriter { let node = MemberDeclBlockSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4234,11 +4234,11 @@ open class SyntaxRewriter { let node = MemberDeclListItemSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4248,11 +4248,11 @@ open class SyntaxRewriter { let node = MemberDeclListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4262,11 +4262,11 @@ open class SyntaxRewriter { let node = MemberTypeIdentifierSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4276,11 +4276,11 @@ open class SyntaxRewriter { let node = MetatypeTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4290,11 +4290,11 @@ open class SyntaxRewriter { let node = MissingDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4304,11 +4304,11 @@ open class SyntaxRewriter { let node = MissingExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4318,11 +4318,11 @@ open class SyntaxRewriter { let node = MissingPatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4332,11 +4332,11 @@ open class SyntaxRewriter { let node = MissingStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4346,11 +4346,11 @@ open class SyntaxRewriter { let node = MissingSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4360,11 +4360,11 @@ open class SyntaxRewriter { let node = MissingTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4374,11 +4374,11 @@ open class SyntaxRewriter { let node = ModifierListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4388,11 +4388,11 @@ open class SyntaxRewriter { let node = MoveExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4402,11 +4402,11 @@ open class SyntaxRewriter { let node = MultipleTrailingClosureElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4416,11 +4416,11 @@ open class SyntaxRewriter { let node = MultipleTrailingClosureElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4430,11 +4430,11 @@ open class SyntaxRewriter { let node = NamedOpaqueReturnTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4444,11 +4444,11 @@ open class SyntaxRewriter { let node = NilLiteralExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4458,11 +4458,11 @@ open class SyntaxRewriter { let node = ObjCSelectorPieceSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4472,11 +4472,11 @@ open class SyntaxRewriter { let node = ObjCSelectorSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4486,11 +4486,11 @@ open class SyntaxRewriter { let node = OpaqueReturnTypeOfAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4500,11 +4500,11 @@ open class SyntaxRewriter { let node = OperatorDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4514,11 +4514,11 @@ open class SyntaxRewriter { let node = OperatorPrecedenceAndTypesSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4528,11 +4528,11 @@ open class SyntaxRewriter { let node = OptionalBindingConditionSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4542,11 +4542,11 @@ open class SyntaxRewriter { let node = OptionalChainingExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4556,11 +4556,11 @@ open class SyntaxRewriter { let node = OptionalTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4570,11 +4570,11 @@ open class SyntaxRewriter { let node = OriginallyDefinedInArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4584,11 +4584,11 @@ open class SyntaxRewriter { let node = PackElementExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4598,11 +4598,11 @@ open class SyntaxRewriter { let node = PackExpansionExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4612,11 +4612,11 @@ open class SyntaxRewriter { let node = PackExpansionTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4626,11 +4626,11 @@ open class SyntaxRewriter { let node = PackReferenceTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4640,11 +4640,11 @@ open class SyntaxRewriter { let node = ParameterClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4654,11 +4654,11 @@ open class SyntaxRewriter { let node = PatternBindingListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4668,11 +4668,11 @@ open class SyntaxRewriter { let node = PatternBindingSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4682,11 +4682,11 @@ open class SyntaxRewriter { let node = PostfixIfConfigExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4696,11 +4696,11 @@ open class SyntaxRewriter { let node = PostfixUnaryExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4710,11 +4710,11 @@ open class SyntaxRewriter { let node = PoundSourceLocationArgsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4724,11 +4724,11 @@ open class SyntaxRewriter { let node = PoundSourceLocationSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4738,11 +4738,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupAssignmentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4752,11 +4752,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupAssociativitySyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4766,11 +4766,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupAttributeListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4780,11 +4780,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4794,11 +4794,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupNameElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4808,11 +4808,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupNameListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4822,11 +4822,11 @@ open class SyntaxRewriter { let node = PrecedenceGroupRelationSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4836,11 +4836,11 @@ open class SyntaxRewriter { let node = PrefixOperatorExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4850,11 +4850,11 @@ open class SyntaxRewriter { let node = PrimaryAssociatedTypeClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4864,11 +4864,11 @@ open class SyntaxRewriter { let node = PrimaryAssociatedTypeListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4878,11 +4878,11 @@ open class SyntaxRewriter { let node = PrimaryAssociatedTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4892,11 +4892,11 @@ open class SyntaxRewriter { let node = ProtocolDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4906,11 +4906,11 @@ open class SyntaxRewriter { let node = QualifiedDeclNameSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4920,11 +4920,11 @@ open class SyntaxRewriter { let node = RegexLiteralExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4934,11 +4934,11 @@ open class SyntaxRewriter { let node = RepeatWhileStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4948,11 +4948,11 @@ open class SyntaxRewriter { let node = ReturnClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4962,11 +4962,11 @@ open class SyntaxRewriter { let node = ReturnStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4976,11 +4976,11 @@ open class SyntaxRewriter { let node = SameTypeRequirementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -4990,11 +4990,11 @@ open class SyntaxRewriter { let node = SequenceExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5004,11 +5004,11 @@ open class SyntaxRewriter { let node = SimpleTypeIdentifierSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5018,11 +5018,11 @@ open class SyntaxRewriter { let node = SourceFileSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5032,11 +5032,11 @@ open class SyntaxRewriter { let node = SpecializeAttributeSpecListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5046,11 +5046,11 @@ open class SyntaxRewriter { let node = SpecializeExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5060,11 +5060,11 @@ open class SyntaxRewriter { let node = StringLiteralExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5074,11 +5074,11 @@ open class SyntaxRewriter { let node = StringLiteralSegmentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5088,11 +5088,11 @@ open class SyntaxRewriter { let node = StringSegmentSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5102,11 +5102,11 @@ open class SyntaxRewriter { let node = StructDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5116,11 +5116,11 @@ open class SyntaxRewriter { let node = SubscriptDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5130,11 +5130,11 @@ open class SyntaxRewriter { let node = SubscriptExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5144,11 +5144,11 @@ open class SyntaxRewriter { let node = SuperRefExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5158,11 +5158,11 @@ open class SyntaxRewriter { let node = SwitchCaseLabelSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5172,11 +5172,11 @@ open class SyntaxRewriter { let node = SwitchCaseListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5186,11 +5186,11 @@ open class SyntaxRewriter { let node = SwitchCaseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5200,11 +5200,11 @@ open class SyntaxRewriter { let node = SwitchDefaultLabelSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5214,11 +5214,11 @@ open class SyntaxRewriter { let node = SwitchExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5228,11 +5228,11 @@ open class SyntaxRewriter { let node = TargetFunctionEntrySyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5242,11 +5242,11 @@ open class SyntaxRewriter { let node = TernaryExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5256,11 +5256,11 @@ open class SyntaxRewriter { let node = ThrowStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5270,11 +5270,11 @@ open class SyntaxRewriter { let node = TryExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5284,11 +5284,11 @@ open class SyntaxRewriter { let node = TupleExprElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5298,11 +5298,11 @@ open class SyntaxRewriter { let node = TupleExprElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5312,11 +5312,11 @@ open class SyntaxRewriter { let node = TupleExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5326,11 +5326,11 @@ open class SyntaxRewriter { let node = TuplePatternElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5340,11 +5340,11 @@ open class SyntaxRewriter { let node = TuplePatternElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5354,11 +5354,11 @@ open class SyntaxRewriter { let node = TuplePatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5368,11 +5368,11 @@ open class SyntaxRewriter { let node = TupleTypeElementListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5382,11 +5382,11 @@ open class SyntaxRewriter { let node = TupleTypeElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5396,11 +5396,11 @@ open class SyntaxRewriter { let node = TupleTypeSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5410,11 +5410,11 @@ open class SyntaxRewriter { let node = TypeAnnotationSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5424,11 +5424,11 @@ open class SyntaxRewriter { let node = TypeEffectSpecifiersSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5438,11 +5438,11 @@ open class SyntaxRewriter { let node = TypeExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5452,11 +5452,11 @@ open class SyntaxRewriter { let node = TypeInheritanceClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5466,11 +5466,11 @@ open class SyntaxRewriter { let node = TypeInitializerClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5480,11 +5480,11 @@ open class SyntaxRewriter { let node = TypealiasDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5494,11 +5494,11 @@ open class SyntaxRewriter { let node = UnavailableFromAsyncArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5508,11 +5508,11 @@ open class SyntaxRewriter { let node = UnderscorePrivateAttributeArgumentsSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5522,11 +5522,11 @@ open class SyntaxRewriter { let node = UnexpectedNodesSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5536,11 +5536,11 @@ open class SyntaxRewriter { let node = UnresolvedAsExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5550,11 +5550,11 @@ open class SyntaxRewriter { let node = UnresolvedIsExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5564,11 +5564,11 @@ open class SyntaxRewriter { let node = UnresolvedPatternExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5578,11 +5578,11 @@ open class SyntaxRewriter { let node = UnresolvedTernaryExprSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5592,11 +5592,11 @@ open class SyntaxRewriter { let node = ValueBindingPatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5606,11 +5606,11 @@ open class SyntaxRewriter { let node = VariableDeclSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5620,11 +5620,11 @@ open class SyntaxRewriter { let node = VersionTupleSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5634,11 +5634,11 @@ open class SyntaxRewriter { let node = WhereClauseSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5648,11 +5648,11 @@ open class SyntaxRewriter { let node = WhileStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5662,11 +5662,11 @@ open class SyntaxRewriter { let node = WildcardPatternSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5676,11 +5676,11 @@ open class SyntaxRewriter { let node = YieldExprListElementSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5690,11 +5690,11 @@ open class SyntaxRewriter { let node = YieldExprListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5704,11 +5704,11 @@ open class SyntaxRewriter { let node = YieldListSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5718,11 +5718,11 @@ open class SyntaxRewriter { let node = YieldStmtSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -5732,11 +5732,11 @@ open class SyntaxRewriter { let node = TokenSyntax(data) // Accessing _syntaxNode directly is faster than calling Syntax(node) visitPre(node._syntaxNode) - defer { - visitPost(node._syntaxNode) + defer { + visitPost(node._syntaxNode) } - if let newNode = visitAny(node._syntaxNode) { - return newNode + if let newNode = visitAny(node._syntaxNode) { + return newNode } return Syntax(visit(node)) } @@ -6310,7 +6310,7 @@ open class SyntaxRewriter { private func visit(_ data: SyntaxData) -> Syntax { return visitationFunc(for: data)(data) } - #else + #else private func visit(_ data: SyntaxData) -> Syntax { switch data.raw.kind { case .token: @@ -6853,7 +6853,7 @@ open class SyntaxRewriter { return visitImplYieldStmtSyntax(data) } } - #endif + #endif private func visitChildren( _ node: SyntaxType @@ -6864,36 +6864,36 @@ open class SyntaxRewriter { // initialize the new layout. Once we know that we have to rewrite the // layout, we need to collect all futher children, regardless of whether // they are rewritten or not. - + // newLayout is nil until the first child node is rewritten and rewritten // nodes are being collected. var newLayout: ContiguousArray? - + // Rewritten children just to keep their 'SyntaxArena' alive until they are // wrapped with 'Syntax' var rewrittens: ContiguousArray = [] - + let syntaxNode = node._syntaxNode - + // Incrementing i manually is faster than using .enumerated() var childIndex = 0 for (raw, info) in RawSyntaxChildren(syntaxNode) { - defer { - childIndex += 1 - } + defer { + childIndex += 1 + } guard let child = raw else { // Node does not exist. If we are collecting rewritten nodes, we need to // collect this one as well, otherwise we can ignore it. if newLayout != nil { newLayout!.append(nil) } - continue + continue } - + // Build the Syntax node to rewrite let absoluteRaw = AbsoluteRawSyntax(raw: child, info: info) let data = SyntaxData(absoluteRaw, parent: syntaxNode) - + let rewritten = visit(data) if rewritten.data.nodeId != info.nodeId { // The node was rewritten, let's handle it @@ -6901,7 +6901,7 @@ open class SyntaxRewriter { // We have not yet collected any previous rewritten nodes. Initialize // the new layout with the previous nodes of the parent. This is // possible, since we know they were not rewritten. - + // The below implementation is based on Collection.map but directly // reserves enough capacity for the entire layout. newLayout = ContiguousArray() @@ -6910,7 +6910,7 @@ open class SyntaxRewriter { newLayout!.append(node.raw.layoutView!.children[j]) } } - + // Now that we know we have a new layout in which we collect rewritten // nodes, add it. rewrittens.append(rewritten) @@ -6923,13 +6923,13 @@ open class SyntaxRewriter { } } } - + if let newLayout = newLayout { // A child node was rewritten. Build the updated node. - + // Sanity check, ensure the new children are the same length. precondition(newLayout.count == node.raw.layoutView!.children.count) - + let arena = SyntaxArena() let newRaw = node.raw.layoutView!.replacingLayout(with: Array(newLayout), arena: arena) // 'withExtendedLifetime' to keep 'SyntaxArena's of them alive until here. @@ -6941,4 +6941,12 @@ open class SyntaxRewriter { return node } } + + /// Rewrite `node` and anchor, making sure that the rewritten node also has + /// a parent if `node` had one. + public func rewrite(_ node: Syntax) -> Syntax { + let rewritten = self.visit(node) + let arena = SyntaxArena() + return Syntax(node.data.replacingSelf(rewritten.raw, arena: arena)) + } } diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift index 9dcf92b57e1..00f641eff88 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift @@ -15,9 +15,9 @@ // MARK: - AttributedSyntax public protocol AttributedSyntax: SyntaxProtocol { - var attributes: AttributeListSyntax? { - get - set + var attributes: AttributeListSyntax? { + get + set } } @@ -51,14 +51,14 @@ public extension SyntaxProtocol { // MARK: - BracedSyntax public protocol BracedSyntax: SyntaxProtocol { - var leftBrace: TokenSyntax { - get - set + var leftBrace: TokenSyntax { + get + set } - var rightBrace: TokenSyntax { - get - set + var rightBrace: TokenSyntax { + get + set } } @@ -92,19 +92,19 @@ public extension SyntaxProtocol { // MARK: - DeclGroupSyntax public protocol DeclGroupSyntax: SyntaxProtocol { - var attributes: AttributeListSyntax? { - get - set + var attributes: AttributeListSyntax? { + get + set } - var modifiers: ModifierListSyntax? { - get - set + var modifiers: ModifierListSyntax? { + get + set } - var memberBlock: MemberDeclBlockSyntax { - get - set + var memberBlock: MemberDeclBlockSyntax { + get + set } } @@ -138,29 +138,29 @@ public extension SyntaxProtocol { // MARK: - EffectSpecifiersSyntax public protocol EffectSpecifiersSyntax: SyntaxProtocol { - var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { - get - set + var unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? { + get + set } - var asyncSpecifier: TokenSyntax? { - get - set + var asyncSpecifier: TokenSyntax? { + get + set } - var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { - get - set + var unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? { + get + set } - var throwsSpecifier: TokenSyntax? { - get - set + var throwsSpecifier: TokenSyntax? { + get + set } - var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { - get - set + var unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? { + get + set } } @@ -194,44 +194,44 @@ public extension SyntaxProtocol { // MARK: - FreestandingMacroExpansionSyntax public protocol FreestandingMacroExpansionSyntax: SyntaxProtocol { - var poundToken: TokenSyntax { - get - set + var poundToken: TokenSyntax { + get + set } - var macro: TokenSyntax { - get - set + var macro: TokenSyntax { + get + set } - var genericArguments: GenericArgumentClauseSyntax? { - get - set + var genericArguments: GenericArgumentClauseSyntax? { + get + set } - var leftParen: TokenSyntax? { - get - set + var leftParen: TokenSyntax? { + get + set } - var argumentList: TupleExprElementListSyntax { - get - set + var argumentList: TupleExprElementListSyntax { + get + set } - var rightParen: TokenSyntax? { - get - set + var rightParen: TokenSyntax? { + get + set } - var trailingClosure: ClosureExprSyntax? { - get - set + var trailingClosure: ClosureExprSyntax? { + get + set } - var additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? { - get - set + var additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? { + get + set } } @@ -265,9 +265,9 @@ public extension SyntaxProtocol { // MARK: - IdentifiedDeclSyntax public protocol IdentifiedDeclSyntax: SyntaxProtocol { - var identifier: TokenSyntax { - get - set + var identifier: TokenSyntax { + get + set } } @@ -301,14 +301,14 @@ public extension SyntaxProtocol { // MARK: - ParenthesizedSyntax public protocol ParenthesizedSyntax: SyntaxProtocol { - var leftParen: TokenSyntax { - get - set + var leftParen: TokenSyntax { + get + set } - var rightParen: TokenSyntax { - get - set + var rightParen: TokenSyntax { + get + set } } @@ -342,9 +342,9 @@ public extension SyntaxProtocol { // MARK: - WithCodeBlockSyntax public protocol WithCodeBlockSyntax: SyntaxProtocol { - var body: CodeBlockSyntax { - get - set + var body: CodeBlockSyntax { + get + set } } @@ -378,9 +378,9 @@ public extension SyntaxProtocol { // MARK: - WithStatementsSyntax public protocol WithStatementsSyntax: SyntaxProtocol { - var statements: CodeBlockItemListSyntax { - get - set + var statements: CodeBlockItemListSyntax { + get + set } } @@ -414,9 +414,9 @@ public extension SyntaxProtocol { // MARK: - WithTrailingCommaSyntax public protocol WithTrailingCommaSyntax: SyntaxProtocol { - var trailingComma: TokenSyntax? { - get - set + var trailingComma: TokenSyntax? { + get + set } } diff --git a/Sources/SwiftSyntax/generated/SyntaxTransform.swift b/Sources/SwiftSyntax/generated/SyntaxTransform.swift index 40967c51cf5..4d84a26cc30 100644 --- a/Sources/SwiftSyntax/generated/SyntaxTransform.swift +++ b/Sources/SwiftSyntax/generated/SyntaxTransform.swift @@ -3802,7 +3802,7 @@ extension SyntaxTransformVisitor { public func visitChildren(_ node: SyntaxType) -> [ResultType] { let syntaxNode = Syntax(node) - return NonNilRawSyntaxChildren(syntaxNode, viewMode: .sourceAccurate).map { rawChild in + return NonNilRawSyntaxChildren(syntaxNode, viewMode: .sourceAccurate).map { rawChild in let child = Syntax(SyntaxData(rawChild, parent: syntaxNode)) return visit(child) } diff --git a/Sources/SwiftSyntax/generated/TokenKind.swift b/Sources/SwiftSyntax/generated/TokenKind.swift index e3958611ec2..fa94fa43ca3 100644 --- a/Sources/SwiftSyntax/generated/TokenKind.swift +++ b/Sources/SwiftSyntax/generated/TokenKind.swift @@ -766,7 +766,7 @@ extension TokenKind { return .integerLiteral(text) case .keyword: var text = text - return text.withSyntaxText { text in + return text.withSyntaxText { text in return .keyword(Keyword(text)!) } case .leftAngle: diff --git a/Sources/SwiftSyntax/generated/Tokens.swift b/Sources/SwiftSyntax/generated/Tokens.swift index 3ad25b165e9..af957e837ac 100644 --- a/Sources/SwiftSyntax/generated/Tokens.swift +++ b/Sources/SwiftSyntax/generated/Tokens.swift @@ -14,713 +14,713 @@ extension TokenSyntax { public static func arrowToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .arrow, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .arrow, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func atSignToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .atSign, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .atSign, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func backslashToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .backslash, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .backslash, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func backtickToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .backtick, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .backtick, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func binaryOperator( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .binaryOperator(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .binaryOperator(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func colonToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .colon, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .colon, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func commaToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .comma, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .comma, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func dollarIdentifier( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .dollarIdentifier(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .dollarIdentifier(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func ellipsisToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .ellipsis, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .ellipsis, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func equalToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .equal, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .equal, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func exclamationMarkToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .exclamationMark, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .exclamationMark, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func extendedRegexDelimiter( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .extendedRegexDelimiter(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .extendedRegexDelimiter(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func floatingLiteral( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .floatingLiteral(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .floatingLiteral(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func identifier( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .identifier(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .identifier(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func infixQuestionMarkToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .infixQuestionMark, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .infixQuestionMark, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func integerLiteral( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .integerLiteral(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .integerLiteral(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func keyword( - _ value: Keyword, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ value: Keyword, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .keyword(value), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .keyword(value), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func leftAngleToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .leftAngle, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .leftAngle, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func leftBraceToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .leftBrace, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .leftBrace, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func leftParenToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .leftParen, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .leftParen, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func leftSquareBracketToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .leftSquareBracket, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .leftSquareBracket, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func multilineStringQuoteToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .multilineStringQuote, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .multilineStringQuote, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func periodToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .period, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .period, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func postfixOperator( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .postfixOperator(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .postfixOperator(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func postfixQuestionMarkToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .postfixQuestionMark, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .postfixQuestionMark, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .pound, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .pound, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundAvailableKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundAvailableKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundAvailableKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundElseKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundElseKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundElseKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundElseifKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundElseifKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundElseifKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundEndifKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundEndifKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundEndifKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundIfKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundIfKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundIfKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundSourceLocationKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundSourceLocationKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundSourceLocationKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func poundUnavailableKeyword( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .poundUnavailableKeyword, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .poundUnavailableKeyword, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func prefixAmpersandToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .prefixAmpersand, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .prefixAmpersand, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func prefixOperator( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .prefixOperator(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .prefixOperator(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func rawStringDelimiter( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .rawStringDelimiter(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .rawStringDelimiter(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func regexLiteralPattern( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .regexLiteralPattern(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .regexLiteralPattern(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func regexSlashToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .regexSlash, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .regexSlash, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func rightAngleToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .rightAngle, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .rightAngle, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func rightBraceToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .rightBrace, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .rightBrace, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func rightParenToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .rightParen, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .rightParen, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func rightSquareBracketToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .rightSquareBracket, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .rightSquareBracket, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func semicolonToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .semicolon, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .semicolon, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func singleQuoteToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .singleQuote, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .singleQuote, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func stringQuoteToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .stringQuote, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .stringQuote, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func stringSegment( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .stringSegment(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .stringSegment(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func unknown( - _ text: String, - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], - presence: SourcePresence = .present + _ text: String, + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], + presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .unknown(text), - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .unknown(text), + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func wildcardToken( - leadingTrivia: Trivia = [], - trailingTrivia: Trivia = [], + leadingTrivia: Trivia = [], + trailingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .wildcard, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia, - presence: presence - + .wildcard, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + presence: presence + ) } public static func eof( - leadingTrivia: Trivia = [], + leadingTrivia: Trivia = [], presence: SourcePresence = .present ) -> TokenSyntax { return TokenSyntax( - .eof, - leadingTrivia: leadingTrivia, - trailingTrivia: [], - presence: presence - + .eof, + leadingTrivia: leadingTrivia, + trailingTrivia: [], + presence: presence + ) } } diff --git a/Sources/SwiftSyntax/generated/TriviaPieces.swift b/Sources/SwiftSyntax/generated/TriviaPieces.swift index 8a9925e4925..2a3ef213fde 100644 --- a/Sources/SwiftSyntax/generated/TriviaPieces.swift +++ b/Sources/SwiftSyntax/generated/TriviaPieces.swift @@ -59,8 +59,8 @@ extension TriviaPiece: TextOutputStreamable { /// - Parameter stream: The stream to which to print the trivia. public func write(to target: inout Target) where Target: TextOutputStream { func printRepeated(_ character: String, count: Int) { - for _ in 0 ..< count { - target.write(character) + for _ in 0 ..< count { + target.write(character) } } switch self { @@ -463,3 +463,73 @@ extension RawTriviaPiece { } } } + +extension TriviaPiece { + /// Returns `true` if this piece is a newline, space or tab. + public var isWhitespace: Bool { + return isSpaceOrTab || isNewline + } + + public var isNewline: Bool { + switch self { + case .carriageReturns: + return true + case .carriageReturnLineFeeds: + return true + case .formfeeds: + return true + case .newlines: + return true + case .verticalTabs: + return true + default: + return false + } + } + + public var isSpaceOrTab: Bool { + switch self { + case .spaces: + return true + case .tabs: + return true + default: + return false + } + } +} + +extension RawTriviaPiece { + /// Returns `true` if this piece is a newline, space or tab. + public var isWhitespace: Bool { + return isSpaceOrTab || isNewline + } + + public var isNewline: Bool { + switch self { + case .carriageReturns: + return true + case .carriageReturnLineFeeds: + return true + case .formfeeds: + return true + case .newlines: + return true + case .verticalTabs: + return true + default: + return false + } + } + + public var isSpaceOrTab: Bool { + switch self { + case .spaces: + return true + case .tabs: + return true + default: + return false + } + } +} diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift index 76b85615604..a21a469aebf 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodes.swift @@ -50,8 +50,8 @@ public struct RawAccessPathComponentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -65,7 +65,7 @@ public struct RawAccessPathComponentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessPathComponent, uninitializedCount: 5, arena: arena) { layout in + kind: .accessPathComponent, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -120,18 +120,18 @@ public struct RawAccessPathSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawAccessPathComponentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .accessPath, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .accessPath, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -141,8 +141,8 @@ public struct RawAccessPathSyntax: RawSyntaxNodeProtocol { } public var elements: [RawAccessPathComponentSyntax] { - layoutView.children.map { - RawAccessPathComponentSyntax(raw: $0!) + layoutView.children.map { + RawAccessPathComponentSyntax(raw: $0!) } } } @@ -170,8 +170,8 @@ public struct RawAccessorBlockSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -187,7 +187,7 @@ public struct RawAccessorBlockSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorBlock, uninitializedCount: 7, arena: arena) { layout in + kind: .accessorBlock, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftBrace?.raw layout[1] = leftBrace.raw @@ -252,8 +252,8 @@ public struct RawAccessorDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -275,7 +275,7 @@ public struct RawAccessorDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorDecl, uninitializedCount: 13, arena: arena) { layout in + kind: .accessorDecl, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -370,8 +370,8 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -385,7 +385,7 @@ public struct RawAccessorEffectSpecifiersSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in + kind: .accessorEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsyncSpecifier?.raw layout[1] = asyncSpecifier?.raw @@ -440,18 +440,18 @@ public struct RawAccessorListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawAccessorDeclSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .accessorList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .accessorList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -461,8 +461,8 @@ public struct RawAccessorListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawAccessorDeclSyntax] { - layoutView.children.map { - RawAccessorDeclSyntax(raw: $0!) + layoutView.children.map { + RawAccessorDeclSyntax(raw: $0!) } } } @@ -490,8 +490,8 @@ public struct RawAccessorParameterSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -507,7 +507,7 @@ public struct RawAccessorParameterSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .accessorParameter, uninitializedCount: 7, arena: arena) { layout in + kind: .accessorParameter, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -572,8 +572,8 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -599,7 +599,7 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .actorDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .actorDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -714,18 +714,18 @@ public struct RawArrayElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawArrayElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .arrayElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .arrayElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -735,8 +735,8 @@ public struct RawArrayElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawArrayElementSyntax] { - layoutView.children.map { - RawArrayElementSyntax(raw: $0!) + layoutView.children.map { + RawArrayElementSyntax(raw: $0!) } } } @@ -764,8 +764,8 @@ public struct RawArrayElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -779,7 +779,7 @@ public struct RawArrayElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .arrayElement, uninitializedCount: 5, arena: arena) { layout in + kind: .arrayElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -834,8 +834,8 @@ public struct RawArrayExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -851,7 +851,7 @@ public struct RawArrayExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .arrayExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .arrayExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftSquare?.raw layout[1] = leftSquare.raw @@ -916,8 +916,8 @@ public struct RawArrayTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -933,7 +933,7 @@ public struct RawArrayTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .arrayType, uninitializedCount: 7, arena: arena) { layout in + kind: .arrayType, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftSquareBracket?.raw layout[1] = leftSquareBracket.raw @@ -998,8 +998,8 @@ public struct RawArrowExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1013,7 +1013,7 @@ public struct RawArrowExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .arrowExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .arrowExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeEffectSpecifiers?.raw layout[1] = effectSpecifiers?.raw @@ -1068,8 +1068,8 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1087,7 +1087,7 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .asExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .asExpr, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -1162,8 +1162,8 @@ public struct RawAssignmentExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1175,7 +1175,7 @@ public struct RawAssignmentExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .assignmentExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .assignmentExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAssignToken?.raw layout[1] = assignToken.raw @@ -1220,8 +1220,8 @@ public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1245,7 +1245,7 @@ public struct RawAssociatedtypeDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .associatedtypeDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .associatedtypeDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -1340,9 +1340,9 @@ public struct RawAttributeListSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .attribute(let node): + case .attribute(let node): return node.raw - case .ifConfigDecl(let node): + case .ifConfigDecl(let node): return node.raw } } @@ -1350,11 +1350,11 @@ public struct RawAttributeListSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawAttributeSyntax(other) { self = .attribute(node) - return + return } if let node = RawIfConfigDeclSyntax(other) { self = .ifConfigDecl(node) - return + return } return nil } @@ -1381,18 +1381,18 @@ public struct RawAttributeListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [Element], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .attributeList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .attributeList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -1402,8 +1402,8 @@ public struct RawAttributeListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawSyntax] { - layoutView.children.map { - RawSyntax(raw: $0!) + layoutView.children.map { + RawSyntax(raw: $0!) } } } @@ -1439,45 +1439,45 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .argumentList(let node): + case .argumentList(let node): return node.raw - case .token(let node): + case .token(let node): return node.raw - case .string(let node): + case .string(let node): return node.raw - case .availability(let node): + case .availability(let node): return node.raw - case .specializeArguments(let node): + case .specializeArguments(let node): return node.raw - case .objCName(let node): + case .objCName(let node): return node.raw - case .implementsArguments(let node): + case .implementsArguments(let node): return node.raw - case .differentiableArguments(let node): + case .differentiableArguments(let node): return node.raw - case .derivativeRegistrationArguments(let node): + case .derivativeRegistrationArguments(let node): return node.raw - case .backDeployedArguments(let node): + case .backDeployedArguments(let node): return node.raw - case .conventionArguments(let node): + case .conventionArguments(let node): return node.raw - case .conventionWitnessMethodArguments(let node): + case .conventionWitnessMethodArguments(let node): return node.raw - case .opaqueReturnTypeOfAttributeArguments(let node): + case .opaqueReturnTypeOfAttributeArguments(let node): return node.raw - case .exposeAttributeArguments(let node): + case .exposeAttributeArguments(let node): return node.raw - case .originallyDefinedInArguments(let node): + case .originallyDefinedInArguments(let node): return node.raw - case .underscorePrivateAttributeArguments(let node): + case .underscorePrivateAttributeArguments(let node): return node.raw - case .dynamicReplacementArguments(let node): + case .dynamicReplacementArguments(let node): return node.raw - case .unavailableFromAsyncArguments(let node): + case .unavailableFromAsyncArguments(let node): return node.raw - case .effectsArguments(let node): + case .effectsArguments(let node): return node.raw - case .documentationArguments(let node): + case .documentationArguments(let node): return node.raw } } @@ -1485,83 +1485,83 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawTupleExprElementListSyntax(other) { self = .argumentList(node) - return + return } if let node = RawTokenSyntax(other) { self = .token(node) - return + return } if let node = RawStringLiteralExprSyntax(other) { self = .string(node) - return + return } if let node = RawAvailabilitySpecListSyntax(other) { self = .availability(node) - return + return } if let node = RawSpecializeAttributeSpecListSyntax(other) { self = .specializeArguments(node) - return + return } if let node = RawObjCSelectorSyntax(other) { self = .objCName(node) - return + return } if let node = RawImplementsAttributeArgumentsSyntax(other) { self = .implementsArguments(node) - return + return } if let node = RawDifferentiableAttributeArgumentsSyntax(other) { self = .differentiableArguments(node) - return + return } if let node = RawDerivativeRegistrationAttributeArgumentsSyntax(other) { self = .derivativeRegistrationArguments(node) - return + return } if let node = RawBackDeployedAttributeSpecListSyntax(other) { self = .backDeployedArguments(node) - return + return } if let node = RawConventionAttributeArgumentsSyntax(other) { self = .conventionArguments(node) - return + return } if let node = RawConventionWitnessMethodAttributeArgumentsSyntax(other) { self = .conventionWitnessMethodArguments(node) - return + return } if let node = RawOpaqueReturnTypeOfAttributeArgumentsSyntax(other) { self = .opaqueReturnTypeOfAttributeArguments(node) - return + return } if let node = RawExposeAttributeArgumentsSyntax(other) { self = .exposeAttributeArguments(node) - return + return } if let node = RawOriginallyDefinedInArgumentsSyntax(other) { self = .originallyDefinedInArguments(node) - return + return } if let node = RawUnderscorePrivateAttributeArgumentsSyntax(other) { self = .underscorePrivateAttributeArguments(node) - return + return } if let node = RawDynamicReplacementArgumentsSyntax(other) { self = .dynamicReplacementArguments(node) - return + return } if let node = RawUnavailableFromAsyncArgumentsSyntax(other) { self = .unavailableFromAsyncArguments(node) - return + return } if let node = RawEffectsArgumentsSyntax(other) { self = .effectsArguments(node) - return + return } if let node = RawDocumentationAttributeArgumentsSyntax(other) { self = .documentationArguments(node) - return + return } return nil } @@ -1588,8 +1588,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1609,7 +1609,7 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .attribute, uninitializedCount: 11, arena: arena) { layout in + kind: .attribute, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAtSignToken?.raw layout[1] = atSignToken.raw @@ -1694,8 +1694,8 @@ public struct RawAttributedTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1711,7 +1711,7 @@ public struct RawAttributedTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .attributedType, uninitializedCount: 7, arena: arena) { layout in + kind: .attributedType, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSpecifier?.raw layout[1] = specifier?.raw @@ -1767,11 +1767,11 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .token(let node): + case .token(let node): return node.raw - case .availabilityVersionRestriction(let node): + case .availabilityVersionRestriction(let node): return node.raw - case .availabilityLabeledArgument(let node): + case .availabilityLabeledArgument(let node): return node.raw } } @@ -1779,15 +1779,15 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawTokenSyntax(other) { self = .token(node) - return + return } if let node = RawAvailabilityVersionRestrictionSyntax(other) { self = .availabilityVersionRestriction(node) - return + return } if let node = RawAvailabilityLabeledArgumentSyntax(other) { self = .availabilityLabeledArgument(node) - return + return } return nil } @@ -1814,8 +1814,8 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1829,7 +1829,7 @@ public struct RawAvailabilityArgumentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .availabilityArgument, uninitializedCount: 5, arena: arena) { layout in + kind: .availabilityArgument, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeEntry?.raw layout[1] = entry.raw @@ -1884,8 +1884,8 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1903,7 +1903,7 @@ public struct RawAvailabilityConditionSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .availabilityCondition, uninitializedCount: 9, arena: arena) { layout in + kind: .availabilityCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAvailabilityKeyword?.raw layout[1] = availabilityKeyword.raw @@ -1978,8 +1978,8 @@ public struct RawAvailabilityEntrySyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -1997,7 +1997,7 @@ public struct RawAvailabilityEntrySyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .availabilityEntry, uninitializedCount: 9, arena: arena) { layout in + kind: .availabilityEntry, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label.raw @@ -2062,9 +2062,9 @@ public struct RawAvailabilityLabeledArgumentSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .string(let node): + case .string(let node): return node.raw - case .version(let node): + case .version(let node): return node.raw } } @@ -2072,11 +2072,11 @@ public struct RawAvailabilityLabeledArgumentSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawStringLiteralExprSyntax(other) { self = .string(node) - return + return } if let node = RawVersionTupleSyntax(other) { self = .version(node) - return + return } return nil } @@ -2103,8 +2103,8 @@ public struct RawAvailabilityLabeledArgumentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2120,7 +2120,7 @@ public struct RawAvailabilityLabeledArgumentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .availabilityLabeledArgument, uninitializedCount: 7, arena: arena) { layout in + kind: .availabilityLabeledArgument, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label.raw @@ -2185,18 +2185,18 @@ public struct RawAvailabilitySpecListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawAvailabilityArgumentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .availabilitySpecList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .availabilitySpecList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -2206,8 +2206,8 @@ public struct RawAvailabilitySpecListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawAvailabilityArgumentSyntax] { - layoutView.children.map { - RawAvailabilityArgumentSyntax(raw: $0!) + layoutView.children.map { + RawAvailabilityArgumentSyntax(raw: $0!) } } } @@ -2235,8 +2235,8 @@ public struct RawAvailabilityVersionRestrictionListEntrySyntax: RawSyntaxNodePro } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2250,7 +2250,7 @@ public struct RawAvailabilityVersionRestrictionListEntrySyntax: RawSyntaxNodePro arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .availabilityVersionRestrictionListEntry, uninitializedCount: 5, arena: arena) { layout in + kind: .availabilityVersionRestrictionListEntry, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAvailabilityVersionRestriction?.raw layout[1] = availabilityVersionRestriction.raw @@ -2305,18 +2305,18 @@ public struct RawAvailabilityVersionRestrictionListSyntax: RawSyntaxNodeProtocol } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawAvailabilityVersionRestrictionListEntrySyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .availabilityVersionRestrictionList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .availabilityVersionRestrictionList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -2326,8 +2326,8 @@ public struct RawAvailabilityVersionRestrictionListSyntax: RawSyntaxNodeProtocol } public var elements: [RawAvailabilityVersionRestrictionListEntrySyntax] { - layoutView.children.map { - RawAvailabilityVersionRestrictionListEntrySyntax(raw: $0!) + layoutView.children.map { + RawAvailabilityVersionRestrictionListEntrySyntax(raw: $0!) } } } @@ -2355,8 +2355,8 @@ public struct RawAvailabilityVersionRestrictionSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2370,7 +2370,7 @@ public struct RawAvailabilityVersionRestrictionSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .availabilityVersionRestriction, uninitializedCount: 5, arena: arena) { layout in + kind: .availabilityVersionRestriction, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePlatform?.raw layout[1] = platform.raw @@ -2425,8 +2425,8 @@ public struct RawAwaitExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2440,7 +2440,7 @@ public struct RawAwaitExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .awaitExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .awaitExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAwaitKeyword?.raw layout[1] = awaitKeyword.raw @@ -2495,8 +2495,8 @@ public struct RawBackDeployedAttributeSpecListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2512,7 +2512,7 @@ public struct RawBackDeployedAttributeSpecListSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .backDeployedAttributeSpecList, uninitializedCount: 7, arena: arena) { layout in + kind: .backDeployedAttributeSpecList, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBeforeLabel?.raw layout[1] = beforeLabel.raw @@ -2577,8 +2577,8 @@ public struct RawBinaryOperatorExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2590,7 +2590,7 @@ public struct RawBinaryOperatorExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .binaryOperatorExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .binaryOperatorExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeOperatorToken?.raw layout[1] = operatorToken.raw @@ -2635,8 +2635,8 @@ public struct RawBooleanLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2648,7 +2648,7 @@ public struct RawBooleanLiteralExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .booleanLiteralExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .booleanLiteralExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBooleanLiteral?.raw layout[1] = booleanLiteral.raw @@ -2693,8 +2693,8 @@ public struct RawBorrowExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2708,7 +2708,7 @@ public struct RawBorrowExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .borrowExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .borrowExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBorrowKeyword?.raw layout[1] = borrowKeyword.raw @@ -2763,8 +2763,8 @@ public struct RawBreakStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2778,7 +2778,7 @@ public struct RawBreakStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .breakStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .breakStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBreakKeyword?.raw layout[1] = breakKeyword.raw @@ -2833,18 +2833,18 @@ public struct RawCaseItemListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawCaseItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .caseItemList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .caseItemList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -2854,8 +2854,8 @@ public struct RawCaseItemListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawCaseItemSyntax] { - layoutView.children.map { - RawCaseItemSyntax(raw: $0!) + layoutView.children.map { + RawCaseItemSyntax(raw: $0!) } } } @@ -2883,8 +2883,8 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -2900,7 +2900,7 @@ public struct RawCaseItemSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in + kind: .caseItem, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePattern?.raw layout[1] = pattern.raw @@ -2965,18 +2965,18 @@ public struct RawCatchClauseListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawCatchClauseSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .catchClauseList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .catchClauseList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -2986,8 +2986,8 @@ public struct RawCatchClauseListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawCatchClauseSyntax] { - layoutView.children.map { - RawCatchClauseSyntax(raw: $0!) + layoutView.children.map { + RawCatchClauseSyntax(raw: $0!) } } } @@ -3015,8 +3015,8 @@ public struct RawCatchClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3032,7 +3032,7 @@ public struct RawCatchClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .catchClause, uninitializedCount: 7, arena: arena) { layout in + kind: .catchClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeCatchKeyword?.raw layout[1] = catchKeyword.raw @@ -3097,18 +3097,18 @@ public struct RawCatchItemListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawCatchItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .catchItemList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .catchItemList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -3118,8 +3118,8 @@ public struct RawCatchItemListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawCatchItemSyntax] { - layoutView.children.map { - RawCatchItemSyntax(raw: $0!) + layoutView.children.map { + RawCatchItemSyntax(raw: $0!) } } } @@ -3147,8 +3147,8 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3164,7 +3164,7 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .catchItem, uninitializedCount: 7, arena: arena) { layout in + kind: .catchItem, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePattern?.raw layout[1] = pattern?.raw @@ -3229,8 +3229,8 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3256,7 +3256,7 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .classDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .classDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -3371,8 +3371,8 @@ public struct RawClassRestrictionTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3384,7 +3384,7 @@ public struct RawClassRestrictionTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .classRestrictionType, uninitializedCount: 3, arena: arena) { layout in + kind: .classRestrictionType, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeClassKeyword?.raw layout[1] = classKeyword.raw @@ -3429,18 +3429,18 @@ public struct RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawClosureCaptureItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .closureCaptureItemList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .closureCaptureItemList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -3450,8 +3450,8 @@ public struct RawClosureCaptureItemListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawClosureCaptureItemSyntax] { - layoutView.children.map { - RawClosureCaptureItemSyntax(raw: $0!) + layoutView.children.map { + RawClosureCaptureItemSyntax(raw: $0!) } } } @@ -3479,8 +3479,8 @@ public struct RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3498,7 +3498,7 @@ public struct RawClosureCaptureItemSpecifierSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureCaptureItemSpecifier, uninitializedCount: 9, arena: arena) { layout in + kind: .closureCaptureItemSpecifier, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSpecifier?.raw layout[1] = specifier.raw @@ -3573,8 +3573,8 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3594,7 +3594,7 @@ public struct RawClosureCaptureItemSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureCaptureItem, uninitializedCount: 11, arena: arena) { layout in + kind: .closureCaptureItem, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSpecifier?.raw layout[1] = specifier?.raw @@ -3679,8 +3679,8 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3696,7 +3696,7 @@ public struct RawClosureCaptureSignatureSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureCaptureSignature, uninitializedCount: 7, arena: arena) { layout in + kind: .closureCaptureSignature, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftSquare?.raw layout[1] = leftSquare.raw @@ -3761,8 +3761,8 @@ public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3780,7 +3780,7 @@ public struct RawClosureExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .closureExpr, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftBrace?.raw layout[1] = leftBrace.raw @@ -3855,18 +3855,18 @@ public struct RawClosureParamListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawClosureParamSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .closureParamList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .closureParamList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -3876,8 +3876,8 @@ public struct RawClosureParamListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawClosureParamSyntax] { - layoutView.children.map { - RawClosureParamSyntax(raw: $0!) + layoutView.children.map { + RawClosureParamSyntax(raw: $0!) } } } @@ -3905,8 +3905,8 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3920,7 +3920,7 @@ public struct RawClosureParamSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureParam, uninitializedCount: 5, arena: arena) { layout in + kind: .closureParam, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -3975,8 +3975,8 @@ public struct RawClosureParameterClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -3992,7 +3992,7 @@ public struct RawClosureParameterClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureParameterClause, uninitializedCount: 7, arena: arena) { layout in + kind: .closureParameterClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -4057,18 +4057,18 @@ public struct RawClosureParameterListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawClosureParameterSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .closureParameterList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .closureParameterList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -4078,8 +4078,8 @@ public struct RawClosureParameterListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawClosureParameterSyntax] { - layoutView.children.map { - RawClosureParameterSyntax(raw: $0!) + layoutView.children.map { + RawClosureParameterSyntax(raw: $0!) } } } @@ -4107,8 +4107,8 @@ public struct RawClosureParameterSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4134,7 +4134,7 @@ public struct RawClosureParameterSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureParameter, uninitializedCount: 17, arena: arena) { layout in + kind: .closureParameter, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -4239,9 +4239,9 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .simpleInput(let node): + case .simpleInput(let node): return node.raw - case .input(let node): + case .input(let node): return node.raw } } @@ -4249,11 +4249,11 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawClosureParamListSyntax(other) { self = .simpleInput(node) - return + return } if let node = RawClosureParameterClauseSyntax(other) { self = .input(node) - return + return } return nil } @@ -4280,8 +4280,8 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4303,7 +4303,7 @@ public struct RawClosureSignatureSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .closureSignature, uninitializedCount: 13, arena: arena) { layout in + kind: .closureSignature, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -4398,18 +4398,18 @@ public struct RawCodeBlockItemListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawCodeBlockItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .codeBlockItemList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .codeBlockItemList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -4419,8 +4419,8 @@ public struct RawCodeBlockItemListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawCodeBlockItemSyntax] { - layoutView.children.map { - RawCodeBlockItemSyntax(raw: $0!) + layoutView.children.map { + RawCodeBlockItemSyntax(raw: $0!) } } } @@ -4439,11 +4439,11 @@ public struct RawCodeBlockItemSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .decl(let node): + case .decl(let node): return node.raw - case .stmt(let node): + case .stmt(let node): return node.raw - case .expr(let node): + case .expr(let node): return node.raw } } @@ -4451,15 +4451,15 @@ public struct RawCodeBlockItemSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawDeclSyntax(other) { self = .decl(node) - return + return } if let node = RawStmtSyntax(other) { self = .stmt(node) - return + return } if let node = RawExprSyntax(other) { self = .expr(node) - return + return } return nil } @@ -4486,8 +4486,8 @@ public struct RawCodeBlockItemSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4501,7 +4501,7 @@ public struct RawCodeBlockItemSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .codeBlockItem, uninitializedCount: 5, arena: arena) { layout in + kind: .codeBlockItem, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeItem?.raw layout[1] = item.raw @@ -4556,8 +4556,8 @@ public struct RawCodeBlockSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4573,7 +4573,7 @@ public struct RawCodeBlockSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .codeBlock, uninitializedCount: 7, arena: arena) { layout in + kind: .codeBlock, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftBrace?.raw layout[1] = leftBrace.raw @@ -4638,18 +4638,18 @@ public struct RawCompositionTypeElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawCompositionTypeElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .compositionTypeElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .compositionTypeElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -4659,8 +4659,8 @@ public struct RawCompositionTypeElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawCompositionTypeElementSyntax] { - layoutView.children.map { - RawCompositionTypeElementSyntax(raw: $0!) + layoutView.children.map { + RawCompositionTypeElementSyntax(raw: $0!) } } } @@ -4688,8 +4688,8 @@ public struct RawCompositionTypeElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4703,7 +4703,7 @@ public struct RawCompositionTypeElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .compositionTypeElement, uninitializedCount: 5, arena: arena) { layout in + kind: .compositionTypeElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeType?.raw layout[1] = type.raw @@ -4758,8 +4758,8 @@ public struct RawCompositionTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4771,7 +4771,7 @@ public struct RawCompositionTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .compositionType, uninitializedCount: 3, arena: arena) { layout in + kind: .compositionType, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeElements?.raw layout[1] = elements.raw @@ -4816,18 +4816,18 @@ public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawConditionElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .conditionElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .conditionElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -4837,8 +4837,8 @@ public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawConditionElementSyntax] { - layoutView.children.map { - RawConditionElementSyntax(raw: $0!) + layoutView.children.map { + RawConditionElementSyntax(raw: $0!) } } } @@ -4858,13 +4858,13 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .expression(let node): + case .expression(let node): return node.raw - case .availability(let node): + case .availability(let node): return node.raw - case .matchingPattern(let node): + case .matchingPattern(let node): return node.raw - case .optionalBinding(let node): + case .optionalBinding(let node): return node.raw } } @@ -4872,19 +4872,19 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawExprSyntax(other) { self = .expression(node) - return + return } if let node = RawAvailabilityConditionSyntax(other) { self = .availability(node) - return + return } if let node = RawMatchingPatternConditionSyntax(other) { self = .matchingPattern(node) - return + return } if let node = RawOptionalBindingConditionSyntax(other) { self = .optionalBinding(node) - return + return } return nil } @@ -4911,8 +4911,8 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4926,7 +4926,7 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .conditionElement, uninitializedCount: 5, arena: arena) { layout in + kind: .conditionElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeCondition?.raw layout[1] = condition.raw @@ -4981,8 +4981,8 @@ public struct RawConformanceRequirementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -4998,7 +4998,7 @@ public struct RawConformanceRequirementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .conformanceRequirement, uninitializedCount: 7, arena: arena) { layout in + kind: .conformanceRequirement, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftTypeIdentifier?.raw layout[1] = leftTypeIdentifier.raw @@ -5063,8 +5063,8 @@ public struct RawConstrainedSugarTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5078,7 +5078,7 @@ public struct RawConstrainedSugarTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .constrainedSugarType, uninitializedCount: 5, arena: arena) { layout in + kind: .constrainedSugarType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSomeOrAnySpecifier?.raw layout[1] = someOrAnySpecifier.raw @@ -5133,8 +5133,8 @@ public struct RawContinueStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5148,7 +5148,7 @@ public struct RawContinueStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .continueStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .continueStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeContinueKeyword?.raw layout[1] = continueKeyword.raw @@ -5203,8 +5203,8 @@ public struct RawConventionAttributeArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5224,7 +5224,7 @@ public struct RawConventionAttributeArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .conventionAttributeArguments, uninitializedCount: 11, arena: arena) { layout in + kind: .conventionAttributeArguments, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeConventionLabel?.raw layout[1] = conventionLabel.raw @@ -5309,8 +5309,8 @@ public struct RawConventionWitnessMethodAttributeArgumentsSyntax: RawSyntaxNodeP } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5326,7 +5326,7 @@ public struct RawConventionWitnessMethodAttributeArgumentsSyntax: RawSyntaxNodeP arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .conventionWitnessMethodAttributeArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .conventionWitnessMethodAttributeArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWitnessMethodLabel?.raw layout[1] = witnessMethodLabel.raw @@ -5391,8 +5391,8 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5408,7 +5408,7 @@ public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .declModifierDetail, uninitializedCount: 7, arena: arena) { layout in + kind: .declModifierDetail, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -5473,8 +5473,8 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5488,7 +5488,7 @@ public struct RawDeclModifierSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .declModifier, uninitializedCount: 5, arena: arena) { layout in + kind: .declModifier, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -5543,18 +5543,18 @@ public struct RawDeclNameArgumentListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawDeclNameArgumentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .declNameArgumentList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .declNameArgumentList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -5564,8 +5564,8 @@ public struct RawDeclNameArgumentListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawDeclNameArgumentSyntax] { - layoutView.children.map { - RawDeclNameArgumentSyntax(raw: $0!) + layoutView.children.map { + RawDeclNameArgumentSyntax(raw: $0!) } } } @@ -5593,8 +5593,8 @@ public struct RawDeclNameArgumentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5608,7 +5608,7 @@ public struct RawDeclNameArgumentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .declNameArgument, uninitializedCount: 5, arena: arena) { layout in + kind: .declNameArgument, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -5663,8 +5663,8 @@ public struct RawDeclNameArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5680,7 +5680,7 @@ public struct RawDeclNameArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .declNameArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .declNameArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -5745,8 +5745,8 @@ public struct RawDeclNameSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5760,7 +5760,7 @@ public struct RawDeclNameSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .declName, uninitializedCount: 5, arena: arena) { layout in + kind: .declName, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDeclBaseName?.raw layout[1] = declBaseName.raw @@ -5801,9 +5801,9 @@ public struct RawDeclSyntax: RawDeclSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .accessorDecl, .actorDecl, .associatedtypeDecl, .classDecl, .deinitializerDecl, .editorPlaceholderDecl, .enumCaseDecl, .enumDecl, .extensionDecl, .functionDecl, .ifConfigDecl, .importDecl, .initializerDecl, .macroDecl, .macroExpansionDecl, .missingDecl, .operatorDecl, .poundSourceLocation, .precedenceGroupDecl, .protocolDecl, .structDecl, .subscriptDecl, .typealiasDecl, .variableDecl: + case .accessorDecl, .actorDecl, .associatedtypeDecl, .classDecl, .deinitializerDecl, .editorPlaceholderDecl, .enumCaseDecl, .enumDecl, .extensionDecl, .functionDecl, .ifConfigDecl, .importDecl, .initializerDecl, .macroDecl, .macroExpansionDecl, .missingDecl, .operatorDecl, .poundSourceLocation, .precedenceGroupDecl, .protocolDecl, .structDecl, .subscriptDecl, .typealiasDecl, .variableDecl: return true - default: + default: return false } } @@ -5820,8 +5820,8 @@ public struct RawDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5854,8 +5854,8 @@ public struct RawDeferStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5869,7 +5869,7 @@ public struct RawDeferStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .deferStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .deferStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDeferKeyword?.raw layout[1] = deferKeyword.raw @@ -5924,8 +5924,8 @@ public struct RawDeinitializerDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -5943,7 +5943,7 @@ public struct RawDeinitializerDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .deinitializerDecl, uninitializedCount: 9, arena: arena) { layout in + kind: .deinitializerDecl, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -6018,8 +6018,8 @@ public struct RawDerivativeRegistrationAttributeArgumentsSyntax: RawSyntaxNodePr } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6043,7 +6043,7 @@ public struct RawDerivativeRegistrationAttributeArgumentsSyntax: RawSyntaxNodePr arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .derivativeRegistrationAttributeArguments, uninitializedCount: 15, arena: arena) { layout in + kind: .derivativeRegistrationAttributeArguments, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeOfLabel?.raw layout[1] = ofLabel.raw @@ -6148,8 +6148,8 @@ public struct RawDesignatedTypeElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6163,7 +6163,7 @@ public struct RawDesignatedTypeElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .designatedTypeElement, uninitializedCount: 5, arena: arena) { layout in + kind: .designatedTypeElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeadingComma?.raw layout[1] = leadingComma.raw @@ -6218,18 +6218,18 @@ public struct RawDesignatedTypeListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawDesignatedTypeElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .designatedTypeList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .designatedTypeList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -6239,8 +6239,8 @@ public struct RawDesignatedTypeListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawDesignatedTypeElementSyntax] { - layoutView.children.map { - RawDesignatedTypeElementSyntax(raw: $0!) + layoutView.children.map { + RawDesignatedTypeElementSyntax(raw: $0!) } } } @@ -6268,18 +6268,18 @@ public struct RawDictionaryElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawDictionaryElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .dictionaryElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .dictionaryElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -6289,8 +6289,8 @@ public struct RawDictionaryElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawDictionaryElementSyntax] { - layoutView.children.map { - RawDictionaryElementSyntax(raw: $0!) + layoutView.children.map { + RawDictionaryElementSyntax(raw: $0!) } } } @@ -6318,8 +6318,8 @@ public struct RawDictionaryElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6337,7 +6337,7 @@ public struct RawDictionaryElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .dictionaryElement, uninitializedCount: 9, arena: arena) { layout in + kind: .dictionaryElement, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeKeyExpression?.raw layout[1] = keyExpression.raw @@ -6402,9 +6402,9 @@ public struct RawDictionaryExprSyntax: RawExprSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .colon(let node): + case .colon(let node): return node.raw - case .elements(let node): + case .elements(let node): return node.raw } } @@ -6412,11 +6412,11 @@ public struct RawDictionaryExprSyntax: RawExprSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawTokenSyntax(other) { self = .colon(node) - return + return } if let node = RawDictionaryElementListSyntax(other) { self = .elements(node) - return + return } return nil } @@ -6443,8 +6443,8 @@ public struct RawDictionaryExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6460,7 +6460,7 @@ public struct RawDictionaryExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .dictionaryExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .dictionaryExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftSquare?.raw layout[1] = leftSquare.raw @@ -6525,8 +6525,8 @@ public struct RawDictionaryTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6546,7 +6546,7 @@ public struct RawDictionaryTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .dictionaryType, uninitializedCount: 11, arena: arena) { layout in + kind: .dictionaryType, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftSquareBracket?.raw layout[1] = leftSquareBracket.raw @@ -6631,18 +6631,18 @@ public struct RawDifferentiabilityParamListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawDifferentiabilityParamSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .differentiabilityParamList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .differentiabilityParamList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -6652,8 +6652,8 @@ public struct RawDifferentiabilityParamListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawDifferentiabilityParamSyntax] { - layoutView.children.map { - RawDifferentiabilityParamSyntax(raw: $0!) + layoutView.children.map { + RawDifferentiabilityParamSyntax(raw: $0!) } } } @@ -6681,8 +6681,8 @@ public struct RawDifferentiabilityParamSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6696,7 +6696,7 @@ public struct RawDifferentiabilityParamSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .differentiabilityParam, uninitializedCount: 5, arena: arena) { layout in + kind: .differentiabilityParam, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeParameter?.raw layout[1] = parameter.raw @@ -6741,9 +6741,9 @@ public struct RawDifferentiabilityParamsClauseSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .parameter(let node): + case .parameter(let node): return node.raw - case .parameterList(let node): + case .parameterList(let node): return node.raw } } @@ -6751,11 +6751,11 @@ public struct RawDifferentiabilityParamsClauseSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawDifferentiabilityParamSyntax(other) { self = .parameter(node) - return + return } if let node = RawDifferentiabilityParamsSyntax(other) { self = .parameterList(node) - return + return } return nil } @@ -6782,8 +6782,8 @@ public struct RawDifferentiabilityParamsClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6799,7 +6799,7 @@ public struct RawDifferentiabilityParamsClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .differentiabilityParamsClause, uninitializedCount: 7, arena: arena) { layout in + kind: .differentiabilityParamsClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWrtLabel?.raw layout[1] = wrtLabel.raw @@ -6864,8 +6864,8 @@ public struct RawDifferentiabilityParamsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6881,7 +6881,7 @@ public struct RawDifferentiabilityParamsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .differentiabilityParams, uninitializedCount: 7, arena: arena) { layout in + kind: .differentiabilityParams, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -6946,8 +6946,8 @@ public struct RawDifferentiableAttributeArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -6967,7 +6967,7 @@ public struct RawDifferentiableAttributeArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .differentiableAttributeArguments, uninitializedCount: 11, arena: arena) { layout in + kind: .differentiableAttributeArguments, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDiffKind?.raw layout[1] = diffKind?.raw @@ -7052,8 +7052,8 @@ public struct RawDiscardAssignmentExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7065,7 +7065,7 @@ public struct RawDiscardAssignmentExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .discardAssignmentExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .discardAssignmentExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWildcard?.raw layout[1] = wildcard.raw @@ -7110,8 +7110,8 @@ public struct RawDoStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7127,7 +7127,7 @@ public struct RawDoStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .doStmt, uninitializedCount: 7, arena: arena) { layout in + kind: .doStmt, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDoKeyword?.raw layout[1] = doKeyword.raw @@ -7182,9 +7182,9 @@ public struct RawDocumentationAttributeArgumentSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .token(let node): + case .token(let node): return node.raw - case .string(let node): + case .string(let node): return node.raw } } @@ -7192,11 +7192,11 @@ public struct RawDocumentationAttributeArgumentSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawTokenSyntax(other) { self = .token(node) - return + return } if let node = RawStringLiteralExprSyntax(other) { self = .string(node) - return + return } return nil } @@ -7223,8 +7223,8 @@ public struct RawDocumentationAttributeArgumentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7242,7 +7242,7 @@ public struct RawDocumentationAttributeArgumentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .documentationAttributeArgument, uninitializedCount: 9, arena: arena) { layout in + kind: .documentationAttributeArgument, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label.raw @@ -7317,18 +7317,18 @@ public struct RawDocumentationAttributeArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawDocumentationAttributeArgumentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .documentationAttributeArguments, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .documentationAttributeArguments, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -7338,8 +7338,8 @@ public struct RawDocumentationAttributeArgumentsSyntax: RawSyntaxNodeProtocol { } public var elements: [RawDocumentationAttributeArgumentSyntax] { - layoutView.children.map { - RawDocumentationAttributeArgumentSyntax(raw: $0!) + layoutView.children.map { + RawDocumentationAttributeArgumentSyntax(raw: $0!) } } } @@ -7367,8 +7367,8 @@ public struct RawDynamicReplacementArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7384,7 +7384,7 @@ public struct RawDynamicReplacementArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .dynamicReplacementArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .dynamicReplacementArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeForLabel?.raw layout[1] = forLabel.raw @@ -7449,8 +7449,8 @@ public struct RawEditorPlaceholderDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7462,7 +7462,7 @@ public struct RawEditorPlaceholderDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .editorPlaceholderDecl, uninitializedCount: 3, arena: arena) { layout in + kind: .editorPlaceholderDecl, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIdentifier?.raw layout[1] = identifier.raw @@ -7507,8 +7507,8 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7520,7 +7520,7 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .editorPlaceholderExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .editorPlaceholderExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIdentifier?.raw layout[1] = identifier.raw @@ -7565,18 +7565,18 @@ public struct RawEffectsArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawTokenSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .effectsArguments, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .effectsArguments, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -7586,8 +7586,8 @@ public struct RawEffectsArgumentsSyntax: RawSyntaxNodeProtocol { } public var elements: [RawTokenSyntax] { - layoutView.children.map { - RawTokenSyntax(raw: $0!) + layoutView.children.map { + RawTokenSyntax(raw: $0!) } } } @@ -7615,8 +7615,8 @@ public struct RawEnumCaseDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7634,7 +7634,7 @@ public struct RawEnumCaseDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .enumCaseDecl, uninitializedCount: 9, arena: arena) { layout in + kind: .enumCaseDecl, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -7709,18 +7709,18 @@ public struct RawEnumCaseElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawEnumCaseElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .enumCaseElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .enumCaseElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -7730,8 +7730,8 @@ public struct RawEnumCaseElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawEnumCaseElementSyntax] { - layoutView.children.map { - RawEnumCaseElementSyntax(raw: $0!) + layoutView.children.map { + RawEnumCaseElementSyntax(raw: $0!) } } } @@ -7759,8 +7759,8 @@ public struct RawEnumCaseElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7778,7 +7778,7 @@ public struct RawEnumCaseElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .enumCaseElement, uninitializedCount: 9, arena: arena) { layout in + kind: .enumCaseElement, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIdentifier?.raw layout[1] = identifier.raw @@ -7853,8 +7853,8 @@ public struct RawEnumCaseParameterClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -7870,7 +7870,7 @@ public struct RawEnumCaseParameterClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .enumCaseParameterClause, uninitializedCount: 7, arena: arena) { layout in + kind: .enumCaseParameterClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -7935,18 +7935,18 @@ public struct RawEnumCaseParameterListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawEnumCaseParameterSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .enumCaseParameterList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .enumCaseParameterList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -7956,8 +7956,8 @@ public struct RawEnumCaseParameterListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawEnumCaseParameterSyntax] { - layoutView.children.map { - RawEnumCaseParameterSyntax(raw: $0!) + layoutView.children.map { + RawEnumCaseParameterSyntax(raw: $0!) } } } @@ -7985,8 +7985,8 @@ public struct RawEnumCaseParameterSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8010,7 +8010,7 @@ public struct RawEnumCaseParameterSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .enumCaseParameter, uninitializedCount: 15, arena: arena) { layout in + kind: .enumCaseParameter, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeModifiers?.raw layout[1] = modifiers?.raw @@ -8115,8 +8115,8 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8142,7 +8142,7 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .enumDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .enumDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -8257,8 +8257,8 @@ public struct RawExposeAttributeArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8274,7 +8274,7 @@ public struct RawExposeAttributeArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .exposeAttributeArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .exposeAttributeArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLanguage?.raw layout[1] = language.raw @@ -8339,18 +8339,18 @@ public struct RawExprListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawExprSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .exprList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .exprList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -8360,8 +8360,8 @@ public struct RawExprListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawExprSyntax] { - layoutView.children.map { - RawExprSyntax(raw: $0!) + layoutView.children.map { + RawExprSyntax(raw: $0!) } } } @@ -8375,9 +8375,9 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: + case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, .closureExpr, .dictionaryExpr, .discardAssignmentExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forcedValueExpr, .functionCallExpr, .identifierExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .moveExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .postfixIfConfigExpr, .postfixUnaryExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .specializeExpr, .stringLiteralExpr, .subscriptExpr, .superRefExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedPatternExpr, .unresolvedTernaryExpr: return true - default: + default: return false } } @@ -8394,8 +8394,8 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8428,8 +8428,8 @@ public struct RawExpressionPatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8441,7 +8441,7 @@ public struct RawExpressionPatternSyntax: RawPatternSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .expressionPattern, uninitializedCount: 3, arena: arena) { layout in + kind: .expressionPattern, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -8486,8 +8486,8 @@ public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8507,7 +8507,7 @@ public struct RawExpressionSegmentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .expressionSegment, uninitializedCount: 11, arena: arena) { layout in + kind: .expressionSegment, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBackslash?.raw layout[1] = backslash.raw @@ -8592,8 +8592,8 @@ public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8605,7 +8605,7 @@ public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .expressionStmt, uninitializedCount: 3, arena: arena) { layout in + kind: .expressionStmt, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -8650,8 +8650,8 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8675,7 +8675,7 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .extensionDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .extensionDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -8780,8 +8780,8 @@ public struct RawFallthroughStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8793,7 +8793,7 @@ public struct RawFallthroughStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .fallthroughStmt, uninitializedCount: 3, arena: arena) { layout in + kind: .fallthroughStmt, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeFallthroughKeyword?.raw layout[1] = fallthroughKeyword.raw @@ -8838,8 +8838,8 @@ public struct RawFloatLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8851,7 +8851,7 @@ public struct RawFloatLiteralExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .floatLiteralExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .floatLiteralExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeFloatingDigits?.raw layout[1] = floatingDigits.raw @@ -8896,8 +8896,8 @@ public struct RawForInStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -8927,7 +8927,7 @@ public struct RawForInStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .forInStmt, uninitializedCount: 21, arena: arena) { layout in + kind: .forInStmt, uninitializedCount: 21, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeForKeyword?.raw layout[1] = forKeyword.raw @@ -9062,8 +9062,8 @@ public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9077,7 +9077,7 @@ public struct RawForcedValueExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .forcedValueExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .forcedValueExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -9132,8 +9132,8 @@ public struct RawForgetStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9147,7 +9147,7 @@ public struct RawForgetStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .forgetStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .forgetStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeForgetKeyword?.raw layout[1] = forgetKeyword.raw @@ -9202,8 +9202,8 @@ public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9225,7 +9225,7 @@ public struct RawFunctionCallExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionCallExpr, uninitializedCount: 13, arena: arena) { layout in + kind: .functionCallExpr, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeCalledExpression?.raw layout[1] = calledExpression.raw @@ -9320,8 +9320,8 @@ public struct RawFunctionDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9347,7 +9347,7 @@ public struct RawFunctionDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .functionDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -9462,8 +9462,8 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9477,7 +9477,7 @@ public struct RawFunctionEffectSpecifiersSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in + kind: .functionEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsyncSpecifier?.raw layout[1] = asyncSpecifier?.raw @@ -9532,18 +9532,18 @@ public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawFunctionParameterSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .functionParameterList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .functionParameterList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -9553,8 +9553,8 @@ public struct RawFunctionParameterListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawFunctionParameterSyntax] { - layoutView.children.map { - RawFunctionParameterSyntax(raw: $0!) + layoutView.children.map { + RawFunctionParameterSyntax(raw: $0!) } } } @@ -9582,8 +9582,8 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9611,7 +9611,7 @@ public struct RawFunctionParameterSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionParameter, uninitializedCount: 19, arena: arena) { layout in + kind: .functionParameter, uninitializedCount: 19, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -9736,8 +9736,8 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9753,7 +9753,7 @@ public struct RawFunctionSignatureSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionSignature, uninitializedCount: 7, arena: arena) { layout in + kind: .functionSignature, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeInput?.raw layout[1] = input.raw @@ -9818,8 +9818,8 @@ public struct RawFunctionTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9839,7 +9839,7 @@ public struct RawFunctionTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .functionType, uninitializedCount: 11, arena: arena) { layout in + kind: .functionType, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -9924,8 +9924,8 @@ public struct RawGenericArgumentClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -9941,7 +9941,7 @@ public struct RawGenericArgumentClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .genericArgumentClause, uninitializedCount: 7, arena: arena) { layout in + kind: .genericArgumentClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftAngleBracket?.raw layout[1] = leftAngleBracket.raw @@ -10006,18 +10006,18 @@ public struct RawGenericArgumentListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawGenericArgumentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .genericArgumentList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .genericArgumentList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -10027,8 +10027,8 @@ public struct RawGenericArgumentListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawGenericArgumentSyntax] { - layoutView.children.map { - RawGenericArgumentSyntax(raw: $0!) + layoutView.children.map { + RawGenericArgumentSyntax(raw: $0!) } } } @@ -10056,8 +10056,8 @@ public struct RawGenericArgumentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10071,7 +10071,7 @@ public struct RawGenericArgumentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .genericArgument, uninitializedCount: 5, arena: arena) { layout in + kind: .genericArgument, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeArgumentType?.raw layout[1] = argumentType.raw @@ -10126,8 +10126,8 @@ public struct RawGenericParameterClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10145,7 +10145,7 @@ public struct RawGenericParameterClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .genericParameterClause, uninitializedCount: 9, arena: arena) { layout in + kind: .genericParameterClause, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftAngleBracket?.raw layout[1] = leftAngleBracket.raw @@ -10220,18 +10220,18 @@ public struct RawGenericParameterListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawGenericParameterSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .genericParameterList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .genericParameterList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -10241,8 +10241,8 @@ public struct RawGenericParameterListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawGenericParameterSyntax] { - layoutView.children.map { - RawGenericParameterSyntax(raw: $0!) + layoutView.children.map { + RawGenericParameterSyntax(raw: $0!) } } } @@ -10270,8 +10270,8 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10293,7 +10293,7 @@ public struct RawGenericParameterSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .genericParameter, uninitializedCount: 13, arena: arena) { layout in + kind: .genericParameter, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -10388,18 +10388,18 @@ public struct RawGenericRequirementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawGenericRequirementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .genericRequirementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .genericRequirementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -10409,8 +10409,8 @@ public struct RawGenericRequirementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawGenericRequirementSyntax] { - layoutView.children.map { - RawGenericRequirementSyntax(raw: $0!) + layoutView.children.map { + RawGenericRequirementSyntax(raw: $0!) } } } @@ -10429,11 +10429,11 @@ public struct RawGenericRequirementSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .sameTypeRequirement(let node): + case .sameTypeRequirement(let node): return node.raw - case .conformanceRequirement(let node): + case .conformanceRequirement(let node): return node.raw - case .layoutRequirement(let node): + case .layoutRequirement(let node): return node.raw } } @@ -10441,15 +10441,15 @@ public struct RawGenericRequirementSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawSameTypeRequirementSyntax(other) { self = .sameTypeRequirement(node) - return + return } if let node = RawConformanceRequirementSyntax(other) { self = .conformanceRequirement(node) - return + return } if let node = RawLayoutRequirementSyntax(other) { self = .layoutRequirement(node) - return + return } return nil } @@ -10476,8 +10476,8 @@ public struct RawGenericRequirementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10491,7 +10491,7 @@ public struct RawGenericRequirementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .genericRequirement, uninitializedCount: 5, arena: arena) { layout in + kind: .genericRequirement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBody?.raw layout[1] = body.raw @@ -10546,8 +10546,8 @@ public struct RawGenericWhereClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10561,7 +10561,7 @@ public struct RawGenericWhereClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .genericWhereClause, uninitializedCount: 5, arena: arena) { layout in + kind: .genericWhereClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWhereKeyword?.raw layout[1] = whereKeyword.raw @@ -10616,8 +10616,8 @@ public struct RawGuardStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10635,7 +10635,7 @@ public struct RawGuardStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .guardStmt, uninitializedCount: 9, arena: arena) { layout in + kind: .guardStmt, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeGuardKeyword?.raw layout[1] = guardKeyword.raw @@ -10710,8 +10710,8 @@ public struct RawIdentifierExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10725,7 +10725,7 @@ public struct RawIdentifierExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .identifierExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .identifierExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIdentifier?.raw layout[1] = identifier.raw @@ -10780,8 +10780,8 @@ public struct RawIdentifierPatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10793,7 +10793,7 @@ public struct RawIdentifierPatternSyntax: RawPatternSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .identifierPattern, uninitializedCount: 3, arena: arena) { layout in + kind: .identifierPattern, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIdentifier?.raw layout[1] = identifier.raw @@ -10838,18 +10838,18 @@ public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawIfConfigClauseSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .ifConfigClauseList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .ifConfigClauseList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -10859,8 +10859,8 @@ public struct RawIfConfigClauseListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawIfConfigClauseSyntax] { - layoutView.children.map { - RawIfConfigClauseSyntax(raw: $0!) + layoutView.children.map { + RawIfConfigClauseSyntax(raw: $0!) } } } @@ -10881,15 +10881,15 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .statements(let node): + case .statements(let node): return node.raw - case .switchCases(let node): + case .switchCases(let node): return node.raw - case .decls(let node): + case .decls(let node): return node.raw - case .postfixExpression(let node): + case .postfixExpression(let node): return node.raw - case .attributes(let node): + case .attributes(let node): return node.raw } } @@ -10897,23 +10897,23 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawCodeBlockItemListSyntax(other) { self = .statements(node) - return + return } if let node = RawSwitchCaseListSyntax(other) { self = .switchCases(node) - return + return } if let node = RawMemberDeclListSyntax(other) { self = .decls(node) - return + return } if let node = RawExprSyntax(other) { self = .postfixExpression(node) - return + return } if let node = RawAttributeListSyntax(other) { self = .attributes(node) - return + return } return nil } @@ -10940,8 +10940,8 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -10957,7 +10957,7 @@ public struct RawIfConfigClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ifConfigClause, uninitializedCount: 7, arena: arena) { layout in + kind: .ifConfigClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePoundKeyword?.raw layout[1] = poundKeyword.raw @@ -11022,8 +11022,8 @@ public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11037,7 +11037,7 @@ public struct RawIfConfigDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ifConfigDecl, uninitializedCount: 5, arena: arena) { layout in + kind: .ifConfigDecl, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeClauses?.raw layout[1] = clauses.raw @@ -11082,9 +11082,9 @@ public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .ifExpr(let node): + case .ifExpr(let node): return node.raw - case .codeBlock(let node): + case .codeBlock(let node): return node.raw } } @@ -11092,11 +11092,11 @@ public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawIfExprSyntax(other) { self = .ifExpr(node) - return + return } if let node = RawCodeBlockSyntax(other) { self = .codeBlock(node) - return + return } return nil } @@ -11123,8 +11123,8 @@ public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11144,7 +11144,7 @@ public struct RawIfExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ifExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .ifExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIfKeyword?.raw layout[1] = ifKeyword.raw @@ -11229,8 +11229,8 @@ public struct RawImplementsAttributeArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11248,7 +11248,7 @@ public struct RawImplementsAttributeArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .implementsAttributeArguments, uninitializedCount: 9, arena: arena) { layout in + kind: .implementsAttributeArguments, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeType?.raw layout[1] = type.raw @@ -11323,8 +11323,8 @@ public struct RawImplicitlyUnwrappedOptionalTypeSyntax: RawTypeSyntaxNodeProtoco } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11338,7 +11338,7 @@ public struct RawImplicitlyUnwrappedOptionalTypeSyntax: RawTypeSyntaxNodeProtoco arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .implicitlyUnwrappedOptionalType, uninitializedCount: 5, arena: arena) { layout in + kind: .implicitlyUnwrappedOptionalType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWrappedType?.raw layout[1] = wrappedType.raw @@ -11393,8 +11393,8 @@ public struct RawImportDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11414,7 +11414,7 @@ public struct RawImportDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .importDecl, uninitializedCount: 11, arena: arena) { layout in + kind: .importDecl, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -11499,8 +11499,8 @@ public struct RawInOutExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11514,7 +11514,7 @@ public struct RawInOutExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .inOutExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .inOutExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAmpersand?.raw layout[1] = ampersand.raw @@ -11569,8 +11569,8 @@ public struct RawInfixOperatorExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11586,7 +11586,7 @@ public struct RawInfixOperatorExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .infixOperatorExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .infixOperatorExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftOperand?.raw layout[1] = leftOperand.raw @@ -11651,18 +11651,18 @@ public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawInheritedTypeSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .inheritedTypeList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .inheritedTypeList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -11672,8 +11672,8 @@ public struct RawInheritedTypeListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawInheritedTypeSyntax] { - layoutView.children.map { - RawInheritedTypeSyntax(raw: $0!) + layoutView.children.map { + RawInheritedTypeSyntax(raw: $0!) } } } @@ -11701,8 +11701,8 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11716,7 +11716,7 @@ public struct RawInheritedTypeSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .inheritedType, uninitializedCount: 5, arena: arena) { layout in + kind: .inheritedType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeTypeName?.raw layout[1] = typeName.raw @@ -11771,8 +11771,8 @@ public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11786,7 +11786,7 @@ public struct RawInitializerClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .initializerClause, uninitializedCount: 5, arena: arena) { layout in + kind: .initializerClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeEqual?.raw layout[1] = equal.raw @@ -11841,8 +11841,8 @@ public struct RawInitializerDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11868,7 +11868,7 @@ public struct RawInitializerDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .initializerDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .initializerDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -11983,8 +11983,8 @@ public struct RawIntegerLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -11996,7 +11996,7 @@ public struct RawIntegerLiteralExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .integerLiteralExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .integerLiteralExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDigits?.raw layout[1] = digits.raw @@ -12041,8 +12041,8 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12058,7 +12058,7 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .isExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .isExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -12123,8 +12123,8 @@ public struct RawIsTypePatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12138,7 +12138,7 @@ public struct RawIsTypePatternSyntax: RawPatternSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .isTypePattern, uninitializedCount: 5, arena: arena) { layout in + kind: .isTypePattern, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIsKeyword?.raw layout[1] = isKeyword.raw @@ -12193,18 +12193,18 @@ public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawKeyPathComponentSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .keyPathComponentList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .keyPathComponentList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -12214,8 +12214,8 @@ public struct RawKeyPathComponentListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawKeyPathComponentSyntax] { - layoutView.children.map { - RawKeyPathComponentSyntax(raw: $0!) + layoutView.children.map { + RawKeyPathComponentSyntax(raw: $0!) } } } @@ -12234,11 +12234,11 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .property(let node): + case .property(let node): return node.raw - case .subscript(let node): + case .subscript(let node): return node.raw - case .optional(let node): + case .optional(let node): return node.raw } } @@ -12246,15 +12246,15 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawKeyPathPropertyComponentSyntax(other) { self = .property(node) - return + return } if let node = RawKeyPathSubscriptComponentSyntax(other) { self = .subscript(node) - return + return } if let node = RawKeyPathOptionalComponentSyntax(other) { self = .optional(node) - return + return } return nil } @@ -12281,8 +12281,8 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12296,7 +12296,7 @@ public struct RawKeyPathComponentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathComponent, uninitializedCount: 5, arena: arena) { layout in + kind: .keyPathComponent, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePeriod?.raw layout[1] = period?.raw @@ -12351,8 +12351,8 @@ public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12368,7 +12368,7 @@ public struct RawKeyPathExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .keyPathExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBackslash?.raw layout[1] = backslash.raw @@ -12433,8 +12433,8 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12446,7 +12446,7 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathOptionalComponent, uninitializedCount: 3, arena: arena) { layout in + kind: .keyPathOptionalComponent, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeQuestionOrExclamationMark?.raw layout[1] = questionOrExclamationMark.raw @@ -12491,8 +12491,8 @@ public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12508,7 +12508,7 @@ public struct RawKeyPathPropertyComponentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathPropertyComponent, uninitializedCount: 7, arena: arena) { layout in + kind: .keyPathPropertyComponent, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIdentifier?.raw layout[1] = identifier.raw @@ -12573,8 +12573,8 @@ public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12590,7 +12590,7 @@ public struct RawKeyPathSubscriptComponentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .keyPathSubscriptComponent, uninitializedCount: 7, arena: arena) { layout in + kind: .keyPathSubscriptComponent, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftBracket?.raw layout[1] = leftBracket.raw @@ -12655,8 +12655,8 @@ public struct RawLabeledSpecializeEntrySyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12674,7 +12674,7 @@ public struct RawLabeledSpecializeEntrySyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .labeledSpecializeEntry, uninitializedCount: 9, arena: arena) { layout in + kind: .labeledSpecializeEntry, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label.raw @@ -12749,8 +12749,8 @@ public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12766,7 +12766,7 @@ public struct RawLabeledStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .labeledStmt, uninitializedCount: 7, arena: arena) { layout in + kind: .labeledStmt, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabelName?.raw layout[1] = labelName.raw @@ -12831,8 +12831,8 @@ public struct RawLayoutRequirementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -12858,7 +12858,7 @@ public struct RawLayoutRequirementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .layoutRequirement, uninitializedCount: 17, arena: arena) { layout in + kind: .layoutRequirement, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeTypeIdentifier?.raw layout[1] = typeIdentifier.raw @@ -12973,8 +12973,8 @@ public struct RawMacroDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13000,7 +13000,7 @@ public struct RawMacroDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .macroDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .macroDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -13115,8 +13115,8 @@ public struct RawMacroExpansionDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13142,7 +13142,7 @@ public struct RawMacroExpansionDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .macroExpansionDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .macroExpansionDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePoundToken?.raw layout[1] = poundToken.raw @@ -13257,8 +13257,8 @@ public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13284,7 +13284,7 @@ public struct RawMacroExpansionExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .macroExpansionExpr, uninitializedCount: 17, arena: arena) { layout in + kind: .macroExpansionExpr, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePoundToken?.raw layout[1] = poundToken.raw @@ -13399,8 +13399,8 @@ public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13418,7 +13418,7 @@ public struct RawMatchingPatternConditionSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .matchingPatternCondition, uninitializedCount: 9, arena: arena) { layout in + kind: .matchingPatternCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeCaseKeyword?.raw layout[1] = caseKeyword.raw @@ -13493,8 +13493,8 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13512,7 +13512,7 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .memberAccessExpr, uninitializedCount: 9, arena: arena) { layout in + kind: .memberAccessExpr, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBase?.raw layout[1] = base?.raw @@ -13587,8 +13587,8 @@ public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13604,7 +13604,7 @@ public struct RawMemberDeclBlockSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .memberDeclBlock, uninitializedCount: 7, arena: arena) { layout in + kind: .memberDeclBlock, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftBrace?.raw layout[1] = leftBrace.raw @@ -13669,8 +13669,8 @@ public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13684,7 +13684,7 @@ public struct RawMemberDeclListItemSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .memberDeclListItem, uninitializedCount: 5, arena: arena) { layout in + kind: .memberDeclListItem, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDecl?.raw layout[1] = decl.raw @@ -13739,18 +13739,18 @@ public struct RawMemberDeclListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawMemberDeclListItemSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .memberDeclList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .memberDeclList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -13760,8 +13760,8 @@ public struct RawMemberDeclListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawMemberDeclListItemSyntax] { - layoutView.children.map { - RawMemberDeclListItemSyntax(raw: $0!) + layoutView.children.map { + RawMemberDeclListItemSyntax(raw: $0!) } } } @@ -13789,8 +13789,8 @@ public struct RawMemberTypeIdentifierSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13808,7 +13808,7 @@ public struct RawMemberTypeIdentifierSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .memberTypeIdentifier, uninitializedCount: 9, arena: arena) { layout in + kind: .memberTypeIdentifier, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBaseType?.raw layout[1] = baseType.raw @@ -13883,8 +13883,8 @@ public struct RawMetatypeTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13900,7 +13900,7 @@ public struct RawMetatypeTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .metatypeType, uninitializedCount: 7, arena: arena) { layout in + kind: .metatypeType, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBaseType?.raw layout[1] = baseType.raw @@ -13965,8 +13965,8 @@ public struct RawMissingDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -13976,17 +13976,21 @@ public struct RawMissingDeclSyntax: RawDeclSyntaxNodeProtocol { attributes: RawAttributeListSyntax?, _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil, modifiers: RawModifierListSyntax?, - _ unexpectedAfterModifiers: RawUnexpectedNodesSyntax? = nil, + _ unexpectedBetweenModifiersAndPlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .missingDecl, uninitializedCount: 5, arena: arena) { layout in + kind: .missingDecl, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw layout[2] = unexpectedBetweenAttributesAndModifiers?.raw layout[3] = modifiers?.raw - layout[4] = unexpectedAfterModifiers?.raw + layout[4] = unexpectedBetweenModifiersAndPlaceholder?.raw + layout[5] = placeholder.raw + layout[6] = unexpectedAfterPlaceholder?.raw } self.init(unchecked: raw) } @@ -14007,9 +14011,17 @@ public struct RawMissingDeclSyntax: RawDeclSyntaxNodeProtocol { layoutView.children[3].map(RawModifierListSyntax.init(raw:)) } - public var unexpectedAfterModifiers: RawUnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndPlaceholder: RawUnexpectedNodesSyntax? { layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var placeholder: RawTokenSyntax { + layoutView.children[5].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -14035,24 +14047,39 @@ public struct RawMissingExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } - public init(_ unexpected: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .missingExpr, uninitializedCount: 1, arena: arena) { layout in + kind: .missingExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpected?.raw + layout[0] = unexpectedBeforePlaceholder?.raw + layout[1] = placeholder.raw + layout[2] = unexpectedAfterPlaceholder?.raw } self.init(unchecked: raw) } - public var unexpected: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var placeholder: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -14078,24 +14105,39 @@ public struct RawMissingPatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } - public init(_ unexpected: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .missingPattern, uninitializedCount: 1, arena: arena) { layout in + kind: .missingPattern, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpected?.raw + layout[0] = unexpectedBeforePlaceholder?.raw + layout[1] = placeholder.raw + layout[2] = unexpectedAfterPlaceholder?.raw } self.init(unchecked: raw) } - public var unexpected: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var placeholder: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -14121,24 +14163,39 @@ public struct RawMissingStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } - public init(_ unexpected: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .missingStmt, uninitializedCount: 1, arena: arena) { layout in + kind: .missingStmt, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpected?.raw + layout[0] = unexpectedBeforePlaceholder?.raw + layout[1] = placeholder.raw + layout[2] = unexpectedAfterPlaceholder?.raw } self.init(unchecked: raw) } - public var unexpected: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var placeholder: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -14164,24 +14221,39 @@ public struct RawMissingSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } - public init(_ unexpected: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .missing, uninitializedCount: 1, arena: arena) { layout in + kind: .missing, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpected?.raw + layout[0] = unexpectedBeforePlaceholder?.raw + layout[1] = placeholder.raw + layout[2] = unexpectedAfterPlaceholder?.raw } self.init(unchecked: raw) } - public var unexpected: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var placeholder: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -14207,24 +14279,39 @@ public struct RawMissingTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } - public init(_ unexpected: RawUnexpectedNodesSyntax? = nil, arena: __shared SyntaxArena) { + public init( + _ unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? = nil, + placeholder: RawTokenSyntax, + _ unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? = nil, + arena: __shared SyntaxArena + ) { let raw = RawSyntax.makeLayout( - kind: .missingType, uninitializedCount: 1, arena: arena) { layout in + kind: .missingType, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) - layout[0] = unexpected?.raw + layout[0] = unexpectedBeforePlaceholder?.raw + layout[1] = placeholder.raw + layout[2] = unexpectedAfterPlaceholder?.raw } self.init(unchecked: raw) } - public var unexpected: RawUnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: RawUnexpectedNodesSyntax? { layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:)) } + + public var placeholder: RawTokenSyntax { + layoutView.children[1].map(RawTokenSyntax.init(raw:))! + } + + public var unexpectedAfterPlaceholder: RawUnexpectedNodesSyntax? { + layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:)) + } } @_spi(RawSyntax) @@ -14250,18 +14337,18 @@ public struct RawModifierListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawDeclModifierSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .modifierList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .modifierList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -14271,8 +14358,8 @@ public struct RawModifierListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawDeclModifierSyntax] { - layoutView.children.map { - RawDeclModifierSyntax(raw: $0!) + layoutView.children.map { + RawDeclModifierSyntax(raw: $0!) } } } @@ -14300,8 +14387,8 @@ public struct RawMoveExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14315,7 +14402,7 @@ public struct RawMoveExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .moveExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .moveExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeMoveKeyword?.raw layout[1] = moveKeyword.raw @@ -14370,18 +14457,18 @@ public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawMultipleTrailingClosureElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .multipleTrailingClosureElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .multipleTrailingClosureElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -14391,8 +14478,8 @@ public struct RawMultipleTrailingClosureElementListSyntax: RawSyntaxNodeProtocol } public var elements: [RawMultipleTrailingClosureElementSyntax] { - layoutView.children.map { - RawMultipleTrailingClosureElementSyntax(raw: $0!) + layoutView.children.map { + RawMultipleTrailingClosureElementSyntax(raw: $0!) } } } @@ -14420,8 +14507,8 @@ public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14437,7 +14524,7 @@ public struct RawMultipleTrailingClosureElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .multipleTrailingClosureElement, uninitializedCount: 7, arena: arena) { layout in + kind: .multipleTrailingClosureElement, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label.raw @@ -14502,8 +14589,8 @@ public struct RawNamedOpaqueReturnTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14517,7 +14604,7 @@ public struct RawNamedOpaqueReturnTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .namedOpaqueReturnType, uninitializedCount: 5, arena: arena) { layout in + kind: .namedOpaqueReturnType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeGenericParameters?.raw layout[1] = genericParameters.raw @@ -14572,8 +14659,8 @@ public struct RawNilLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14585,7 +14672,7 @@ public struct RawNilLiteralExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .nilLiteralExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .nilLiteralExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeNilKeyword?.raw layout[1] = nilKeyword.raw @@ -14630,8 +14717,8 @@ public struct RawObjCSelectorPieceSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14645,7 +14732,7 @@ public struct RawObjCSelectorPieceSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .objCSelectorPiece, uninitializedCount: 5, arena: arena) { layout in + kind: .objCSelectorPiece, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name?.raw @@ -14700,18 +14787,18 @@ public struct RawObjCSelectorSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawObjCSelectorPieceSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .objCSelector, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .objCSelector, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -14721,8 +14808,8 @@ public struct RawObjCSelectorSyntax: RawSyntaxNodeProtocol { } public var elements: [RawObjCSelectorPieceSyntax] { - layoutView.children.map { - RawObjCSelectorPieceSyntax(raw: $0!) + layoutView.children.map { + RawObjCSelectorPieceSyntax(raw: $0!) } } } @@ -14750,8 +14837,8 @@ public struct RawOpaqueReturnTypeOfAttributeArgumentsSyntax: RawSyntaxNodeProtoc } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14767,7 +14854,7 @@ public struct RawOpaqueReturnTypeOfAttributeArgumentsSyntax: RawSyntaxNodeProtoc arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .opaqueReturnTypeOfAttributeArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .opaqueReturnTypeOfAttributeArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeMangledName?.raw layout[1] = mangledName.raw @@ -14832,8 +14919,8 @@ public struct RawOperatorDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14853,7 +14940,7 @@ public struct RawOperatorDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .operatorDecl, uninitializedCount: 11, arena: arena) { layout in + kind: .operatorDecl, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -14938,8 +15025,8 @@ public struct RawOperatorPrecedenceAndTypesSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -14955,7 +15042,7 @@ public struct RawOperatorPrecedenceAndTypesSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .operatorPrecedenceAndTypes, uninitializedCount: 7, arena: arena) { layout in + kind: .operatorPrecedenceAndTypes, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeColon?.raw layout[1] = colon.raw @@ -15020,8 +15107,8 @@ public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15039,7 +15126,7 @@ public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .optionalBindingCondition, uninitializedCount: 9, arena: arena) { layout in + kind: .optionalBindingCondition, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBindingKeyword?.raw layout[1] = bindingKeyword.raw @@ -15114,8 +15201,8 @@ public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15129,7 +15216,7 @@ public struct RawOptionalChainingExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .optionalChainingExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .optionalChainingExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -15184,8 +15271,8 @@ public struct RawOptionalTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15199,7 +15286,7 @@ public struct RawOptionalTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .optionalType, uninitializedCount: 5, arena: arena) { layout in + kind: .optionalType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWrappedType?.raw layout[1] = wrappedType.raw @@ -15254,8 +15341,8 @@ public struct RawOriginallyDefinedInArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15275,7 +15362,7 @@ public struct RawOriginallyDefinedInArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .originallyDefinedInArguments, uninitializedCount: 11, arena: arena) { layout in + kind: .originallyDefinedInArguments, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeModuleLabel?.raw layout[1] = moduleLabel.raw @@ -15360,8 +15447,8 @@ public struct RawPackElementExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15375,7 +15462,7 @@ public struct RawPackElementExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .packElementExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .packElementExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeEachKeyword?.raw layout[1] = eachKeyword.raw @@ -15430,8 +15517,8 @@ public struct RawPackExpansionExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15445,7 +15532,7 @@ public struct RawPackExpansionExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .packExpansionExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .packExpansionExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeRepeatKeyword?.raw layout[1] = repeatKeyword.raw @@ -15500,8 +15587,8 @@ public struct RawPackExpansionTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15515,7 +15602,7 @@ public struct RawPackExpansionTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .packExpansionType, uninitializedCount: 5, arena: arena) { layout in + kind: .packExpansionType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeRepeatKeyword?.raw layout[1] = repeatKeyword.raw @@ -15570,8 +15657,8 @@ public struct RawPackReferenceTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15585,7 +15672,7 @@ public struct RawPackReferenceTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .packReferenceType, uninitializedCount: 5, arena: arena) { layout in + kind: .packReferenceType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeEachKeyword?.raw layout[1] = eachKeyword.raw @@ -15640,8 +15727,8 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15657,7 +15744,7 @@ public struct RawParameterClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .parameterClause, uninitializedCount: 7, arena: arena) { layout in + kind: .parameterClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -15722,18 +15809,18 @@ public struct RawPatternBindingListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawPatternBindingSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .patternBindingList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .patternBindingList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -15743,8 +15830,8 @@ public struct RawPatternBindingListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawPatternBindingSyntax] { - layoutView.children.map { - RawPatternBindingSyntax(raw: $0!) + layoutView.children.map { + RawPatternBindingSyntax(raw: $0!) } } } @@ -15762,9 +15849,9 @@ public struct RawPatternBindingSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .accessors(let node): + case .accessors(let node): return node.raw - case .getter(let node): + case .getter(let node): return node.raw } } @@ -15772,11 +15859,11 @@ public struct RawPatternBindingSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawAccessorBlockSyntax(other) { self = .accessors(node) - return + return } if let node = RawCodeBlockSyntax(other) { self = .getter(node) - return + return } return nil } @@ -15803,8 +15890,8 @@ public struct RawPatternBindingSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15824,7 +15911,7 @@ public struct RawPatternBindingSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .patternBinding, uninitializedCount: 11, arena: arena) { layout in + kind: .patternBinding, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePattern?.raw layout[1] = pattern.raw @@ -15895,9 +15982,9 @@ public struct RawPatternSyntax: RawPatternSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .expressionPattern, .identifierPattern, .isTypePattern, .missingPattern, .tuplePattern, .valueBindingPattern, .wildcardPattern: + case .expressionPattern, .identifierPattern, .isTypePattern, .missingPattern, .tuplePattern, .valueBindingPattern, .wildcardPattern: return true - default: + default: return false } } @@ -15914,8 +16001,8 @@ public struct RawPatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15948,8 +16035,8 @@ public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -15963,7 +16050,7 @@ public struct RawPostfixIfConfigExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .postfixIfConfigExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .postfixIfConfigExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBase?.raw layout[1] = base?.raw @@ -16018,8 +16105,8 @@ public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16033,7 +16120,7 @@ public struct RawPostfixUnaryExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .postfixUnaryExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .postfixUnaryExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -16088,8 +16175,8 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16113,7 +16200,7 @@ public struct RawPoundSourceLocationArgsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundSourceLocationArgs, uninitializedCount: 15, arena: arena) { layout in + kind: .poundSourceLocationArgs, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeFileArgLabel?.raw layout[1] = fileArgLabel.raw @@ -16218,8 +16305,8 @@ public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16237,7 +16324,7 @@ public struct RawPoundSourceLocationSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .poundSourceLocation, uninitializedCount: 9, arena: arena) { layout in + kind: .poundSourceLocation, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePoundSourceLocation?.raw layout[1] = poundSourceLocation.raw @@ -16312,8 +16399,8 @@ public struct RawPrecedenceGroupAssignmentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16329,7 +16416,7 @@ public struct RawPrecedenceGroupAssignmentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupAssignment, uninitializedCount: 7, arena: arena) { layout in + kind: .precedenceGroupAssignment, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAssignmentKeyword?.raw layout[1] = assignmentKeyword.raw @@ -16394,8 +16481,8 @@ public struct RawPrecedenceGroupAssociativitySyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16411,7 +16498,7 @@ public struct RawPrecedenceGroupAssociativitySyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupAssociativity, uninitializedCount: 7, arena: arena) { layout in + kind: .precedenceGroupAssociativity, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAssociativityKeyword?.raw layout[1] = associativityKeyword.raw @@ -16467,11 +16554,11 @@ public struct RawPrecedenceGroupAttributeListSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .precedenceGroupRelation(let node): + case .precedenceGroupRelation(let node): return node.raw - case .precedenceGroupAssignment(let node): + case .precedenceGroupAssignment(let node): return node.raw - case .precedenceGroupAssociativity(let node): + case .precedenceGroupAssociativity(let node): return node.raw } } @@ -16479,15 +16566,15 @@ public struct RawPrecedenceGroupAttributeListSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawPrecedenceGroupRelationSyntax(other) { self = .precedenceGroupRelation(node) - return + return } if let node = RawPrecedenceGroupAssignmentSyntax(other) { self = .precedenceGroupAssignment(node) - return + return } if let node = RawPrecedenceGroupAssociativitySyntax(other) { self = .precedenceGroupAssociativity(node) - return + return } return nil } @@ -16514,18 +16601,18 @@ public struct RawPrecedenceGroupAttributeListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [Element], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupAttributeList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .precedenceGroupAttributeList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -16535,8 +16622,8 @@ public struct RawPrecedenceGroupAttributeListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawSyntax] { - layoutView.children.map { - RawSyntax(raw: $0!) + layoutView.children.map { + RawSyntax(raw: $0!) } } } @@ -16564,8 +16651,8 @@ public struct RawPrecedenceGroupDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16589,7 +16676,7 @@ public struct RawPrecedenceGroupDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .precedenceGroupDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -16694,8 +16781,8 @@ public struct RawPrecedenceGroupNameElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16709,7 +16796,7 @@ public struct RawPrecedenceGroupNameElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupNameElement, uninitializedCount: 5, arena: arena) { layout in + kind: .precedenceGroupNameElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -16764,18 +16851,18 @@ public struct RawPrecedenceGroupNameListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawPrecedenceGroupNameElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupNameList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .precedenceGroupNameList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -16785,8 +16872,8 @@ public struct RawPrecedenceGroupNameListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawPrecedenceGroupNameElementSyntax] { - layoutView.children.map { - RawPrecedenceGroupNameElementSyntax(raw: $0!) + layoutView.children.map { + RawPrecedenceGroupNameElementSyntax(raw: $0!) } } } @@ -16814,8 +16901,8 @@ public struct RawPrecedenceGroupRelationSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16831,7 +16918,7 @@ public struct RawPrecedenceGroupRelationSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .precedenceGroupRelation, uninitializedCount: 7, arena: arena) { layout in + kind: .precedenceGroupRelation, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeHigherThanOrLowerThan?.raw layout[1] = higherThanOrLowerThan.raw @@ -16896,8 +16983,8 @@ public struct RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16911,7 +16998,7 @@ public struct RawPrefixOperatorExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .prefixOperatorExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .prefixOperatorExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeOperatorToken?.raw layout[1] = operatorToken?.raw @@ -16966,8 +17053,8 @@ public struct RawPrimaryAssociatedTypeClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -16983,7 +17070,7 @@ public struct RawPrimaryAssociatedTypeClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .primaryAssociatedTypeClause, uninitializedCount: 7, arena: arena) { layout in + kind: .primaryAssociatedTypeClause, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftAngleBracket?.raw layout[1] = leftAngleBracket.raw @@ -17048,18 +17135,18 @@ public struct RawPrimaryAssociatedTypeListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawPrimaryAssociatedTypeSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .primaryAssociatedTypeList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .primaryAssociatedTypeList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -17069,8 +17156,8 @@ public struct RawPrimaryAssociatedTypeListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawPrimaryAssociatedTypeSyntax] { - layoutView.children.map { - RawPrimaryAssociatedTypeSyntax(raw: $0!) + layoutView.children.map { + RawPrimaryAssociatedTypeSyntax(raw: $0!) } } } @@ -17098,8 +17185,8 @@ public struct RawPrimaryAssociatedTypeSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17113,7 +17200,7 @@ public struct RawPrimaryAssociatedTypeSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .primaryAssociatedType, uninitializedCount: 5, arena: arena) { layout in + kind: .primaryAssociatedType, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -17168,8 +17255,8 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17195,7 +17282,7 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .protocolDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .protocolDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -17310,8 +17397,8 @@ public struct RawQualifiedDeclNameSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17329,7 +17416,7 @@ public struct RawQualifiedDeclNameSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .qualifiedDeclName, uninitializedCount: 9, arena: arena) { layout in + kind: .qualifiedDeclName, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBaseType?.raw layout[1] = baseType?.raw @@ -17404,8 +17491,8 @@ public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17425,7 +17512,7 @@ public struct RawRegexLiteralExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .regexLiteralExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .regexLiteralExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeOpeningPounds?.raw layout[1] = openingPounds?.raw @@ -17510,8 +17597,8 @@ public struct RawRepeatWhileStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17529,7 +17616,7 @@ public struct RawRepeatWhileStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .repeatWhileStmt, uninitializedCount: 9, arena: arena) { layout in + kind: .repeatWhileStmt, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeRepeatKeyword?.raw layout[1] = repeatKeyword.raw @@ -17604,8 +17691,8 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17619,7 +17706,7 @@ public struct RawReturnClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .returnClause, uninitializedCount: 5, arena: arena) { layout in + kind: .returnClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeArrow?.raw layout[1] = arrow.raw @@ -17674,8 +17761,8 @@ public struct RawReturnStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17689,7 +17776,7 @@ public struct RawReturnStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .returnStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .returnStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeReturnKeyword?.raw layout[1] = returnKeyword.raw @@ -17744,8 +17831,8 @@ public struct RawSameTypeRequirementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17761,7 +17848,7 @@ public struct RawSameTypeRequirementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .sameTypeRequirement, uninitializedCount: 7, arena: arena) { layout in + kind: .sameTypeRequirement, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftTypeIdentifier?.raw layout[1] = leftTypeIdentifier.raw @@ -17826,8 +17913,8 @@ public struct RawSequenceExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17839,7 +17926,7 @@ public struct RawSequenceExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .sequenceExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .sequenceExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeElements?.raw layout[1] = elements.raw @@ -17884,8 +17971,8 @@ public struct RawSimpleTypeIdentifierSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17899,7 +17986,7 @@ public struct RawSimpleTypeIdentifierSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .simpleTypeIdentifier, uninitializedCount: 5, arena: arena) { layout in + kind: .simpleTypeIdentifier, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeName?.raw layout[1] = name.raw @@ -17954,8 +18041,8 @@ public struct RawSourceFileSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -17969,7 +18056,7 @@ public struct RawSourceFileSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .sourceFile, uninitializedCount: 5, arena: arena) { layout in + kind: .sourceFile, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeStatements?.raw layout[1] = statements.raw @@ -18016,13 +18103,13 @@ public struct RawSpecializeAttributeSpecListSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .labeledSpecializeEntry(let node): + case .labeledSpecializeEntry(let node): return node.raw - case .availabilityEntry(let node): + case .availabilityEntry(let node): return node.raw - case .targetFunctionEntry(let node): + case .targetFunctionEntry(let node): return node.raw - case .genericWhereClause(let node): + case .genericWhereClause(let node): return node.raw } } @@ -18030,19 +18117,19 @@ public struct RawSpecializeAttributeSpecListSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawLabeledSpecializeEntrySyntax(other) { self = .labeledSpecializeEntry(node) - return + return } if let node = RawAvailabilityEntrySyntax(other) { self = .availabilityEntry(node) - return + return } if let node = RawTargetFunctionEntrySyntax(other) { self = .targetFunctionEntry(node) - return + return } if let node = RawGenericWhereClauseSyntax(other) { self = .genericWhereClause(node) - return + return } return nil } @@ -18069,18 +18156,18 @@ public struct RawSpecializeAttributeSpecListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [Element], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .specializeAttributeSpecList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .specializeAttributeSpecList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -18090,8 +18177,8 @@ public struct RawSpecializeAttributeSpecListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawSyntax] { - layoutView.children.map { - RawSyntax(raw: $0!) + layoutView.children.map { + RawSyntax(raw: $0!) } } } @@ -18119,8 +18206,8 @@ public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18134,7 +18221,7 @@ public struct RawSpecializeExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .specializeExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .specializeExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -18175,9 +18262,9 @@ public struct RawStmtSyntax: RawStmtSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .forgetStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: + case .breakStmt, .continueStmt, .deferStmt, .doStmt, .expressionStmt, .fallthroughStmt, .forInStmt, .forgetStmt, .guardStmt, .labeledStmt, .missingStmt, .repeatWhileStmt, .returnStmt, .throwStmt, .whileStmt, .yieldStmt: return true - default: + default: return false } } @@ -18194,8 +18281,8 @@ public struct RawStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18228,8 +18315,8 @@ public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18249,7 +18336,7 @@ public struct RawStringLiteralExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .stringLiteralExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .stringLiteralExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeOpenDelimiter?.raw layout[1] = openDelimiter?.raw @@ -18324,9 +18411,9 @@ public struct RawStringLiteralSegmentsSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .stringSegment(let node): + case .stringSegment(let node): return node.raw - case .expressionSegment(let node): + case .expressionSegment(let node): return node.raw } } @@ -18334,11 +18421,11 @@ public struct RawStringLiteralSegmentsSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawStringSegmentSyntax(other) { self = .stringSegment(node) - return + return } if let node = RawExpressionSegmentSyntax(other) { self = .expressionSegment(node) - return + return } return nil } @@ -18365,18 +18452,18 @@ public struct RawStringLiteralSegmentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [Element], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .stringLiteralSegments, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .stringLiteralSegments, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -18386,8 +18473,8 @@ public struct RawStringLiteralSegmentsSyntax: RawSyntaxNodeProtocol { } public var elements: [RawSyntax] { - layoutView.children.map { - RawSyntax(raw: $0!) + layoutView.children.map { + RawSyntax(raw: $0!) } } } @@ -18415,8 +18502,8 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18428,7 +18515,7 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .stringSegment, uninitializedCount: 3, arena: arena) { layout in + kind: .stringSegment, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeContent?.raw layout[1] = content.raw @@ -18473,8 +18560,8 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18500,7 +18587,7 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .structDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .structDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -18605,9 +18692,9 @@ public struct RawSubscriptDeclSyntax: RawDeclSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .accessors(let node): + case .accessors(let node): return node.raw - case .getter(let node): + case .getter(let node): return node.raw } } @@ -18615,11 +18702,11 @@ public struct RawSubscriptDeclSyntax: RawDeclSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawAccessorBlockSyntax(other) { self = .accessors(node) - return + return } if let node = RawCodeBlockSyntax(other) { self = .getter(node) - return + return } return nil } @@ -18646,8 +18733,8 @@ public struct RawSubscriptDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18673,7 +18760,7 @@ public struct RawSubscriptDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .subscriptDecl, uninitializedCount: 17, arena: arena) { layout in + kind: .subscriptDecl, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -18788,8 +18875,8 @@ public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18811,7 +18898,7 @@ public struct RawSubscriptExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .subscriptExpr, uninitializedCount: 13, arena: arena) { layout in + kind: .subscriptExpr, uninitializedCount: 13, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeCalledExpression?.raw layout[1] = calledExpression.raw @@ -18906,8 +18993,8 @@ public struct RawSuperRefExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18919,7 +19006,7 @@ public struct RawSuperRefExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .superRefExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .superRefExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSuperKeyword?.raw layout[1] = superKeyword.raw @@ -18964,8 +19051,8 @@ public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -18981,7 +19068,7 @@ public struct RawSwitchCaseLabelSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in + kind: .switchCaseLabel, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeCaseKeyword?.raw layout[1] = caseKeyword.raw @@ -19036,9 +19123,9 @@ public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .switchCase(let node): + case .switchCase(let node): return node.raw - case .ifConfigDecl(let node): + case .ifConfigDecl(let node): return node.raw } } @@ -19046,11 +19133,11 @@ public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawSwitchCaseSyntax(other) { self = .switchCase(node) - return + return } if let node = RawIfConfigDeclSyntax(other) { self = .ifConfigDecl(node) - return + return } return nil } @@ -19077,18 +19164,18 @@ public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [Element], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .switchCaseList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .switchCaseList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -19098,8 +19185,8 @@ public struct RawSwitchCaseListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawSyntax] { - layoutView.children.map { - RawSyntax(raw: $0!) + layoutView.children.map { + RawSyntax(raw: $0!) } } } @@ -19117,9 +19204,9 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .default(let node): + case .default(let node): return node.raw - case .case(let node): + case .case(let node): return node.raw } } @@ -19127,11 +19214,11 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawSwitchDefaultLabelSyntax(other) { self = .default(node) - return + return } if let node = RawSwitchCaseLabelSyntax(other) { self = .case(node) - return + return } return nil } @@ -19158,8 +19245,8 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19175,7 +19262,7 @@ public struct RawSwitchCaseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .switchCase, uninitializedCount: 7, arena: arena) { layout in + kind: .switchCase, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeUnknownAttr?.raw layout[1] = unknownAttr?.raw @@ -19240,8 +19327,8 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19255,7 +19342,7 @@ public struct RawSwitchDefaultLabelSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .switchDefaultLabel, uninitializedCount: 5, arena: arena) { layout in + kind: .switchDefaultLabel, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeDefaultKeyword?.raw layout[1] = defaultKeyword.raw @@ -19310,8 +19397,8 @@ public struct RawSwitchExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19331,7 +19418,7 @@ public struct RawSwitchExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .switchExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .switchExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSwitchKeyword?.raw layout[1] = switchKeyword.raw @@ -19416,8 +19503,8 @@ public struct RawTargetFunctionEntrySyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19435,7 +19522,7 @@ public struct RawTargetFunctionEntrySyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .targetFunctionEntry, uninitializedCount: 9, arena: arena) { layout in + kind: .targetFunctionEntry, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label.raw @@ -19510,8 +19597,8 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19531,7 +19618,7 @@ public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .ternaryExpr, uninitializedCount: 11, arena: arena) { layout in + kind: .ternaryExpr, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeConditionExpression?.raw layout[1] = conditionExpression.raw @@ -19616,8 +19703,8 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19631,7 +19718,7 @@ public struct RawThrowStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .throwStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .throwStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeThrowKeyword?.raw layout[1] = throwKeyword.raw @@ -19686,8 +19773,8 @@ public struct RawTryExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19703,7 +19790,7 @@ public struct RawTryExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tryExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .tryExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeTryKeyword?.raw layout[1] = tryKeyword.raw @@ -19768,18 +19855,18 @@ public struct RawTupleExprElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawTupleExprElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .tupleExprElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .tupleExprElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -19789,8 +19876,8 @@ public struct RawTupleExprElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawTupleExprElementSyntax] { - layoutView.children.map { - RawTupleExprElementSyntax(raw: $0!) + layoutView.children.map { + RawTupleExprElementSyntax(raw: $0!) } } } @@ -19818,8 +19905,8 @@ public struct RawTupleExprElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19837,7 +19924,7 @@ public struct RawTupleExprElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tupleExprElement, uninitializedCount: 9, arena: arena) { layout in + kind: .tupleExprElement, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabel?.raw layout[1] = label?.raw @@ -19912,8 +19999,8 @@ public struct RawTupleExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -19929,7 +20016,7 @@ public struct RawTupleExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tupleExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .tupleExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -19994,18 +20081,18 @@ public struct RawTuplePatternElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawTuplePatternElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .tuplePatternElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .tuplePatternElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -20015,8 +20102,8 @@ public struct RawTuplePatternElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawTuplePatternElementSyntax] { - layoutView.children.map { - RawTuplePatternElementSyntax(raw: $0!) + layoutView.children.map { + RawTuplePatternElementSyntax(raw: $0!) } } } @@ -20044,8 +20131,8 @@ public struct RawTuplePatternElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20063,7 +20150,7 @@ public struct RawTuplePatternElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tuplePatternElement, uninitializedCount: 9, arena: arena) { layout in + kind: .tuplePatternElement, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLabelName?.raw layout[1] = labelName?.raw @@ -20138,8 +20225,8 @@ public struct RawTuplePatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20155,7 +20242,7 @@ public struct RawTuplePatternSyntax: RawPatternSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tuplePattern, uninitializedCount: 7, arena: arena) { layout in + kind: .tuplePattern, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -20220,18 +20307,18 @@ public struct RawTupleTypeElementListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawTupleTypeElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .tupleTypeElementList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .tupleTypeElementList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -20241,8 +20328,8 @@ public struct RawTupleTypeElementListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawTupleTypeElementSyntax] { - layoutView.children.map { - RawTupleTypeElementSyntax(raw: $0!) + layoutView.children.map { + RawTupleTypeElementSyntax(raw: $0!) } } } @@ -20270,8 +20357,8 @@ public struct RawTupleTypeElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20297,7 +20384,7 @@ public struct RawTupleTypeElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tupleTypeElement, uninitializedCount: 17, arena: arena) { layout in + kind: .tupleTypeElement, uninitializedCount: 17, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeInOut?.raw layout[1] = inOut?.raw @@ -20412,8 +20499,8 @@ public struct RawTupleTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20429,7 +20516,7 @@ public struct RawTupleTypeSyntax: RawTypeSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .tupleType, uninitializedCount: 7, arena: arena) { layout in + kind: .tupleType, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -20494,8 +20581,8 @@ public struct RawTypeAnnotationSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20509,7 +20596,7 @@ public struct RawTypeAnnotationSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeAnnotation, uninitializedCount: 5, arena: arena) { layout in + kind: .typeAnnotation, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeColon?.raw layout[1] = colon.raw @@ -20564,8 +20651,8 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20579,7 +20666,7 @@ public struct RawTypeEffectSpecifiersSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in + kind: .typeEffectSpecifiers, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsyncSpecifier?.raw layout[1] = asyncSpecifier?.raw @@ -20634,8 +20721,8 @@ public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20647,7 +20734,7 @@ public struct RawTypeExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .typeExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeType?.raw layout[1] = type.raw @@ -20692,8 +20779,8 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20707,7 +20794,7 @@ public struct RawTypeInheritanceClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeInheritanceClause, uninitializedCount: 5, arena: arena) { layout in + kind: .typeInheritanceClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeColon?.raw layout[1] = colon.raw @@ -20762,8 +20849,8 @@ public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20777,7 +20864,7 @@ public struct RawTypeInitializerClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typeInitializerClause, uninitializedCount: 5, arena: arena) { layout in + kind: .typeInitializerClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeEqual?.raw layout[1] = equal.raw @@ -20818,9 +20905,9 @@ public struct RawTypeSyntax: RawTypeSyntaxNodeProtocol { public static func isKindOf(_ raw: RawSyntax) -> Bool { switch raw.kind { - case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType: + case .arrayType, .attributedType, .classRestrictionType, .compositionType, .constrainedSugarType, .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType, .memberTypeIdentifier, .metatypeType, .missingType, .namedOpaqueReturnType, .optionalType, .packExpansionType, .packReferenceType, .simpleTypeIdentifier, .tupleType: return true - default: + default: return false } } @@ -20837,8 +20924,8 @@ public struct RawTypeSyntax: RawTypeSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20871,8 +20958,8 @@ public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -20896,7 +20983,7 @@ public struct RawTypealiasDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .typealiasDecl, uninitializedCount: 15, arena: arena) { layout in + kind: .typealiasDecl, uninitializedCount: 15, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -21001,8 +21088,8 @@ public struct RawUnavailableFromAsyncArgumentsSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21018,7 +21105,7 @@ public struct RawUnavailableFromAsyncArgumentsSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unavailableFromAsyncArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .unavailableFromAsyncArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeMessageLabel?.raw layout[1] = messageLabel.raw @@ -21083,8 +21170,8 @@ public struct RawUnderscorePrivateAttributeArgumentsSyntax: RawSyntaxNodeProtoco } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21100,7 +21187,7 @@ public struct RawUnderscorePrivateAttributeArgumentsSyntax: RawSyntaxNodeProtoco arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .underscorePrivateAttributeArguments, uninitializedCount: 7, arena: arena) { layout in + kind: .underscorePrivateAttributeArguments, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeSourceFileLabel?.raw layout[1] = sourceFileLabel.raw @@ -21165,18 +21252,18 @@ public struct RawUnexpectedNodesSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .unexpectedNodes, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .unexpectedNodes, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -21186,8 +21273,8 @@ public struct RawUnexpectedNodesSyntax: RawSyntaxNodeProtocol { } public var elements: [RawSyntax] { - layoutView.children.map { - RawSyntax(raw: $0!) + layoutView.children.map { + RawSyntax(raw: $0!) } } } @@ -21215,8 +21302,8 @@ public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21230,7 +21317,7 @@ public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unresolvedAsExpr, uninitializedCount: 5, arena: arena) { layout in + kind: .unresolvedAsExpr, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAsTok?.raw layout[1] = asTok.raw @@ -21285,8 +21372,8 @@ public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21298,7 +21385,7 @@ public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unresolvedIsExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .unresolvedIsExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeIsTok?.raw layout[1] = isTok.raw @@ -21343,8 +21430,8 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21356,7 +21443,7 @@ public struct RawUnresolvedPatternExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unresolvedPatternExpr, uninitializedCount: 3, arena: arena) { layout in + kind: .unresolvedPatternExpr, uninitializedCount: 3, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforePattern?.raw layout[1] = pattern.raw @@ -21401,8 +21488,8 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21418,7 +21505,7 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .unresolvedTernaryExpr, uninitializedCount: 7, arena: arena) { layout in + kind: .unresolvedTernaryExpr, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeQuestionMark?.raw layout[1] = questionMark.raw @@ -21483,8 +21570,8 @@ public struct RawValueBindingPatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21498,7 +21585,7 @@ public struct RawValueBindingPatternSyntax: RawPatternSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .valueBindingPattern, uninitializedCount: 5, arena: arena) { layout in + kind: .valueBindingPattern, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeBindingKeyword?.raw layout[1] = bindingKeyword.raw @@ -21553,8 +21640,8 @@ public struct RawVariableDeclSyntax: RawDeclSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21572,7 +21659,7 @@ public struct RawVariableDeclSyntax: RawDeclSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .variableDecl, uninitializedCount: 9, arena: arena) { layout in + kind: .variableDecl, uninitializedCount: 9, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeAttributes?.raw layout[1] = attributes?.raw @@ -21647,8 +21734,8 @@ public struct RawVersionTupleSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21668,7 +21755,7 @@ public struct RawVersionTupleSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .versionTuple, uninitializedCount: 11, arena: arena) { layout in + kind: .versionTuple, uninitializedCount: 11, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeMajor?.raw layout[1] = major.raw @@ -21753,8 +21840,8 @@ public struct RawWhereClauseSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21768,7 +21855,7 @@ public struct RawWhereClauseSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .whereClause, uninitializedCount: 5, arena: arena) { layout in + kind: .whereClause, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWhereKeyword?.raw layout[1] = whereKeyword.raw @@ -21823,8 +21910,8 @@ public struct RawWhileStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21840,7 +21927,7 @@ public struct RawWhileStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .whileStmt, uninitializedCount: 7, arena: arena) { layout in + kind: .whileStmt, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWhileKeyword?.raw layout[1] = whileKeyword.raw @@ -21905,8 +21992,8 @@ public struct RawWildcardPatternSyntax: RawPatternSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21920,7 +22007,7 @@ public struct RawWildcardPatternSyntax: RawPatternSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .wildcardPattern, uninitializedCount: 5, arena: arena) { layout in + kind: .wildcardPattern, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeWildcard?.raw layout[1] = wildcard.raw @@ -21975,8 +22062,8 @@ public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -21990,7 +22077,7 @@ public struct RawYieldExprListElementSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .yieldExprListElement, uninitializedCount: 5, arena: arena) { layout in + kind: .yieldExprListElement, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeExpression?.raw layout[1] = expression.raw @@ -22045,18 +22132,18 @@ public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } public init(elements: [RawYieldExprListElementSyntax], arena: __shared SyntaxArena) { let raw = RawSyntax.makeLayout( - kind: .yieldExprList, uninitializedCount: elements.count, arena: arena) { layout in - guard var ptr = layout.baseAddress else { - return - } + kind: .yieldExprList, uninitializedCount: elements.count, arena: arena) { layout in + guard var ptr = layout.baseAddress else { + return + } for elem in elements { ptr.initialize(to: elem.raw) ptr += 1 @@ -22066,8 +22153,8 @@ public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol { } public var elements: [RawYieldExprListElementSyntax] { - layoutView.children.map { - RawYieldExprListElementSyntax(raw: $0!) + layoutView.children.map { + RawYieldExprListElementSyntax(raw: $0!) } } } @@ -22095,8 +22182,8 @@ public struct RawYieldListSyntax: RawSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -22112,7 +22199,7 @@ public struct RawYieldListSyntax: RawSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .yieldList, uninitializedCount: 7, arena: arena) { layout in + kind: .yieldList, uninitializedCount: 7, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeLeftParen?.raw layout[1] = leftParen.raw @@ -22167,9 +22254,9 @@ public struct RawYieldStmtSyntax: RawStmtSyntaxNodeProtocol { public var raw: RawSyntax { switch self { - case .yieldList(let node): + case .yieldList(let node): return node.raw - case .simpleYield(let node): + case .simpleYield(let node): return node.raw } } @@ -22177,11 +22264,11 @@ public struct RawYieldStmtSyntax: RawStmtSyntaxNodeProtocol { public init?(_ other: T) where T : RawSyntaxNodeProtocol { if let node = RawYieldListSyntax(other) { self = .yieldList(node) - return + return } if let node = RawExprSyntax(other) { self = .simpleYield(node) - return + return } return nil } @@ -22208,8 +22295,8 @@ public struct RawYieldStmtSyntax: RawStmtSyntaxNodeProtocol { } public init?(_ other: Node) { - guard Self.isKindOf(other.raw) else { - return nil + guard Self.isKindOf(other.raw) else { + return nil } self.init(unchecked: other.raw) } @@ -22223,7 +22310,7 @@ public struct RawYieldStmtSyntax: RawStmtSyntaxNodeProtocol { arena: __shared SyntaxArena ) { let raw = RawSyntax.makeLayout( - kind: .yieldStmt, uninitializedCount: 5, arena: arena) { layout in + kind: .yieldStmt, uninitializedCount: 5, arena: arena) { layout in layout.initialize(repeating: nil) layout[0] = unexpectedBeforeYieldKeyword?.raw layout[1] = yieldKeyword.raw diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift index 4f6426b6634..e1b5716c132 100644 --- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift +++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift @@ -34,19 +34,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { } enum ValidationError: CustomStringConvertible { case expectedNonNil(expectedKind: RawSyntaxNodeProtocol.Type, file: StaticString, line: UInt) - case kindMismatch( - expectedKind: RawSyntaxNodeProtocol.Type, - actualKind: SyntaxKind, - file: StaticString, - line: UInt - ) - case tokenMismatch( - expectedTokenChoices: [TokenChoice], - actualKind: RawTokenKind, - actualText: SyntaxText, - file: StaticString, - line: UInt - ) + case kindMismatch(expectedKind: RawSyntaxNodeProtocol.Type, actualKind: SyntaxKind, file: StaticString, line: UInt) + case tokenMismatch(expectedTokenChoices: [TokenChoice], actualKind: RawTokenKind, actualText: SyntaxText, file: StaticString, line: UInt) var description: String { @@ -54,19 +43,19 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .expectedNonNil(expectedKind: let expectedKind, file: _, line: _): return "Expected non-nil node of type \(expectedKind) but received nil" case .kindMismatch( - expectedKind: let expectedKind, - actualKind: let actualKind, - file: _, - line: _ - ): + expectedKind: let expectedKind, + actualKind: let actualKind, + file: _, + line: _ + ): return "Expected node of type \(expectedKind) but received \(actualKind)" case .tokenMismatch( - expectedTokenChoices: let tokenChoices, - actualKind: let actualKind, - actualText: let actualText, - file: _, - line: _ - ): + expectedTokenChoices: let tokenChoices, + actualKind: let actualKind, + actualText: let actualText, + file: _, + line: _ + ): return "Expected token with one of \(tokenChoices) but received \(actualKind) with text '\(actualText)'" } } @@ -77,19 +66,19 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .expectedNonNil(expectedKind: _, file: let file, line: let line): return (file, line) case .kindMismatch( - expectedKind: _, - actualKind: _, - file: let file, - line: let line - ): + expectedKind: _, + actualKind: _, + file: let file, + line: let line + ): return (file, line) case .tokenMismatch( - expectedTokenChoices: _, - actualKind: _, - actualText: _, - file: let file, - line: let line - ): + expectedTokenChoices: _, + actualKind: _, + actualText: _, + file: let file, + line: let line + ): return (file, line) } } @@ -105,11 +94,11 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { } guard Node.isKindOf(raw) else { return .kindMismatch( - expectedKind: Node.self, - actualKind: raw.kind, - file: file, - line: line - ) + expectedKind: Node.self, + actualKind: raw.kind, + file: file, + line: line + ) } return nil } @@ -121,11 +110,11 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { ) -> ValidationError? { if raw != nil { return verify( - raw, - as: Node.self, - file: file, - line: line - ) + raw, + as: Node.self, + file: file, + line: line + ) } return nil } @@ -142,12 +131,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { // regarding it are fixed. if raw != nil { return verify( - raw, - as: RawTokenSyntax.self, - tokenChoices: tokenChoices, - file: file, - line: line - ) + raw, + as: RawTokenSyntax.self, + tokenChoices: tokenChoices, + file: file, + line: line + ) } return nil } @@ -199,8 +188,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { } } func assertAnyHasNoError(_ nodeKind: SyntaxKind, _ index: Int, _ errors: [ValidationError?]) { - let nonNilErrors = errors.compactMap({ - $0 + let nonNilErrors = errors.compactMap({ + $0 }) if nonNilErrors.count == errors.count, let firstError = nonNilErrors.first { let (file, line) = firstError.fileAndLine @@ -380,7 +369,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .attributeList: for (index, element) in layout.enumerated() { assertAnyHasNoError(kind, index, [ - verify(element, as: RawAttributeSyntax.self), + verify(element, as: RawAttributeSyntax.self), verify(element, as: RawIfConfigDeclSyntax.self)]) } case .attribute: @@ -1784,27 +1773,39 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.keyword("Type"), .keyword("Protocol")])) assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .missingDecl: - assert(layout.count == 5) + assert(layout.count == 7) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax?.self)) assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) assertNoError(kind, 3, verify(layout[3], as: RawModifierListSyntax?.self)) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self)) case .missingExpr: - assert(layout.count == 1) + assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .missingPattern: - assert(layout.count == 1) + assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .missingStmt: - assert(layout.count == 1) + assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .missing: - assert(layout.count == 1) + assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .missingType: - assert(layout.count == 1) + assert(layout.count == 3) assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self)) + assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)])) + assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self)) case .modifierList: for (index, element) in layout.enumerated() { assertNoError(kind, index, verify(element, as: RawDeclModifierSyntax.self)) @@ -2039,8 +2040,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .precedenceGroupAttributeList: for (index, element) in layout.enumerated() { assertAnyHasNoError(kind, index, [ - verify(element, as: RawPrecedenceGroupRelationSyntax.self), - verify(element, as: RawPrecedenceGroupAssignmentSyntax.self), + verify(element, as: RawPrecedenceGroupRelationSyntax.self), + verify(element, as: RawPrecedenceGroupAssignmentSyntax.self), verify(element, as: RawPrecedenceGroupAssociativitySyntax.self)]) } case .precedenceGroupDecl: @@ -2212,9 +2213,9 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .specializeAttributeSpecList: for (index, element) in layout.enumerated() { assertAnyHasNoError(kind, index, [ - verify(element, as: RawLabeledSpecializeEntrySyntax.self), - verify(element, as: RawAvailabilityEntrySyntax.self), - verify(element, as: RawTargetFunctionEntrySyntax.self), + verify(element, as: RawLabeledSpecializeEntrySyntax.self), + verify(element, as: RawAvailabilityEntrySyntax.self), + verify(element, as: RawTargetFunctionEntrySyntax.self), verify(element, as: RawGenericWhereClauseSyntax.self) ]) } @@ -2241,7 +2242,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .stringLiteralSegments: for (index, element) in layout.enumerated() { assertAnyHasNoError(kind, index, [ - verify(element, as: RawStringSegmentSyntax.self), + verify(element, as: RawStringSegmentSyntax.self), verify(element, as: RawExpressionSegmentSyntax.self)]) } case .stringSegment: @@ -2320,7 +2321,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { case .switchCaseList: for (index, element) in layout.enumerated() { assertAnyHasNoError(kind, index, [ - verify(element, as: RawSwitchCaseSyntax.self), + verify(element, as: RawSwitchCaseSyntax.self), verify(element, as: RawIfConfigDeclSyntax.self)]) } case .switchCase: @@ -2654,5 +2655,5 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) { verify(layout[3], as: RawSyntax.self)]) assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self)) } - #endif + #endif } diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift index 918abc67483..7c222d03f1a 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxDeclNodes.swift @@ -19,8 +19,8 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorDecl else { - return nil + guard node.raw.kind == .accessorDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -34,20 +34,20 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifier: UnexpectedNodesSyntax? = nil, - modifier: DeclModifierSyntax? = nil, - _ unexpectedBetweenModifierAndAccessorKind: UnexpectedNodesSyntax? = nil, - accessorKind: TokenSyntax, - _ unexpectedBetweenAccessorKindAndParameter: UnexpectedNodesSyntax? = nil, - parameter: AccessorParameterSyntax? = nil, - _ unexpectedBetweenParameterAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: AccessorEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax? = nil, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifier: UnexpectedNodesSyntax? = nil, + modifier: DeclModifierSyntax? = nil, + _ unexpectedBetweenModifierAndAccessorKind: UnexpectedNodesSyntax? = nil, + accessorKind: TokenSyntax, + _ unexpectedBetweenAccessorKindAndParameter: UnexpectedNodesSyntax? = nil, + parameter: AccessorParameterSyntax? = nil, + _ unexpectedBetweenParameterAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: AccessorEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax? = nil, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -67,7 +67,7 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenEffectSpecifiersAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -84,12 +84,13 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.accessorDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -125,8 +126,8 @@ public struct AccessorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return AccessorDeclSyntax(newData) @@ -257,8 +258,8 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .actorDecl else { - return nil + guard node.raw.kind == .actorDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -272,24 +273,24 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil, - actorKeyword: TokenSyntax = .keyword(.actor), - _ unexpectedBetweenActorKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberDeclBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil, + actorKeyword: TokenSyntax = .keyword(.actor), + _ unexpectedBetweenActorKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberDeclBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -313,7 +314,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock, unexpectedAfterMemberBlock - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -334,12 +335,13 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterMemberBlock?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.actorDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.actorDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -375,8 +377,8 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ActorDeclSyntax(newData) @@ -412,8 +414,8 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ActorDeclSyntax(newData) @@ -566,8 +568,8 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .associatedtypeDecl else { - return nil + guard node.raw.kind == .associatedtypeDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -581,22 +583,22 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndAssociatedtypeKeyword: UnexpectedNodesSyntax? = nil, - associatedtypeKeyword: TokenSyntax = .keyword(.associatedtype), - _ unexpectedBetweenAssociatedtypeKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: TypeInitializerClauseSyntax? = nil, - _ unexpectedBetweenInitializerAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndAssociatedtypeKeyword: UnexpectedNodesSyntax? = nil, + associatedtypeKeyword: TokenSyntax = .keyword(.associatedtype), + _ unexpectedBetweenAssociatedtypeKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: TypeInitializerClauseSyntax? = nil, + _ unexpectedBetweenInitializerAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -618,7 +620,7 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenInitializerAndGenericWhereClause, genericWhereClause, unexpectedAfterGenericWhereClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -637,12 +639,13 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.associatedtypeDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.associatedtypeDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -678,8 +681,8 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return AssociatedtypeDeclSyntax(newData) @@ -715,8 +718,8 @@ public struct AssociatedtypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return AssociatedtypeDeclSyntax(newData) @@ -849,8 +852,8 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .classDecl else { - return nil + guard node.raw.kind == .classDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -864,24 +867,24 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil, - classKeyword: TokenSyntax = .keyword(.class), - _ unexpectedBetweenClassKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberDeclBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil, + classKeyword: TokenSyntax = .keyword(.class), + _ unexpectedBetweenClassKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberDeclBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -905,7 +908,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock, unexpectedAfterMemberBlock - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -926,12 +929,13 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterMemberBlock?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.classDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.classDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -967,8 +971,8 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ClassDeclSyntax(newData) @@ -1004,8 +1008,8 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ClassDeclSyntax(newData) @@ -1158,8 +1162,8 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .deinitializerDecl else { - return nil + guard node.raw.kind == .deinitializerDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1173,16 +1177,16 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndDeinitKeyword: UnexpectedNodesSyntax? = nil, - deinitKeyword: TokenSyntax = .keyword(.deinit), - _ unexpectedBetweenDeinitKeywordAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax? = nil, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndDeinitKeyword: UnexpectedNodesSyntax? = nil, + deinitKeyword: TokenSyntax = .keyword(.deinit), + _ unexpectedBetweenDeinitKeywordAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax? = nil, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1198,7 +1202,7 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenDeinitKeywordAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -1211,12 +1215,13 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.deinitializerDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.deinitializerDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1252,8 +1257,8 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return DeinitializerDeclSyntax(newData) @@ -1289,8 +1294,8 @@ public struct DeinitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return DeinitializerDeclSyntax(newData) @@ -1363,8 +1368,8 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .editorPlaceholderDecl else { - return nil + guard node.raw.kind == .editorPlaceholderDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1378,24 +1383,25 @@ public struct EditorPlaceholderDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedAfterIdentifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedAfterIdentifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeIdentifier?.raw, identifier.raw, unexpectedAfterIdentifier?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.editorPlaceholderDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.editorPlaceholderDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1440,8 +1446,8 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseDecl else { - return nil + guard node.raw.kind == .enumCaseDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1455,16 +1461,16 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndElements: UnexpectedNodesSyntax? = nil, - elements: EnumCaseElementListSyntax, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndElements: UnexpectedNodesSyntax? = nil, + elements: EnumCaseElementListSyntax, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1480,7 +1486,7 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenCaseKeywordAndElements, elements, unexpectedAfterElements - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -1493,12 +1499,13 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterElements?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.enumCaseDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1535,8 +1542,8 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return EnumCaseDeclSyntax(newData) @@ -1573,8 +1580,8 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return EnumCaseDeclSyntax(newData) @@ -1630,8 +1637,8 @@ public struct EnumCaseDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[7] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 7, with: collection, arena: arena) return EnumCaseDeclSyntax(newData) @@ -1668,8 +1675,8 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumDecl else { - return nil + guard node.raw.kind == .enumDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1683,24 +1690,24 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil, - enumKeyword: TokenSyntax = .keyword(.enum), - _ unexpectedBetweenEnumKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameters: UnexpectedNodesSyntax? = nil, - genericParameters: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParametersAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberDeclBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil, + enumKeyword: TokenSyntax = .keyword(.enum), + _ unexpectedBetweenEnumKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameters: UnexpectedNodesSyntax? = nil, + genericParameters: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParametersAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberDeclBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1724,7 +1731,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock, unexpectedAfterMemberBlock - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -1745,12 +1752,13 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterMemberBlock?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.enumDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1787,8 +1795,8 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return EnumDeclSyntax(newData) @@ -1825,8 +1833,8 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return EnumDeclSyntax(newData) @@ -1985,8 +1993,8 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .extensionDecl else { - return nil + guard node.raw.kind == .extensionDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2000,22 +2008,22 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil, - extensionKeyword: TokenSyntax = .keyword(.extension), - _ unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil, - extendedType: E, - _ unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberDeclBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil, + extensionKeyword: TokenSyntax = .keyword(.extension), + _ unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil, + extendedType: E, + _ unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberDeclBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2037,7 +2045,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock, unexpectedAfterMemberBlock - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -2056,12 +2064,13 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterMemberBlock?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.extensionDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.extensionDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2097,8 +2106,8 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ExtensionDeclSyntax(newData) @@ -2134,8 +2143,8 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ExtensionDeclSyntax(newData) @@ -2268,8 +2277,8 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionDecl else { - return nil + guard node.raw.kind == .functionDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2283,24 +2292,24 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndFuncKeyword: UnexpectedNodesSyntax? = nil, - funcKeyword: TokenSyntax = .keyword(.func), - _ unexpectedBetweenFuncKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndSignature: UnexpectedNodesSyntax? = nil, - signature: FunctionSignatureSyntax, - _ unexpectedBetweenSignatureAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax? = nil, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFuncKeyword: UnexpectedNodesSyntax? = nil, + funcKeyword: TokenSyntax = .keyword(.func), + _ unexpectedBetweenFuncKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndSignature: UnexpectedNodesSyntax? = nil, + signature: FunctionSignatureSyntax, + _ unexpectedBetweenSignatureAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax? = nil, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2324,7 +2333,7 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -2345,12 +2354,13 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.functionDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2386,8 +2396,8 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return FunctionDeclSyntax(newData) @@ -2423,8 +2433,8 @@ public struct FunctionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return FunctionDeclSyntax(newData) @@ -2577,8 +2587,8 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ifConfigDecl else { - return nil + guard node.raw.kind == .ifConfigDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2592,12 +2602,12 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeClauses: UnexpectedNodesSyntax? = nil, - clauses: IfConfigClauseListSyntax, - _ unexpectedBetweenClausesAndPoundEndif: UnexpectedNodesSyntax? = nil, - poundEndif: TokenSyntax = .poundEndifKeyword(), - _ unexpectedAfterPoundEndif: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeClauses: UnexpectedNodesSyntax? = nil, + clauses: IfConfigClauseListSyntax, + _ unexpectedBetweenClausesAndPoundEndif: UnexpectedNodesSyntax? = nil, + poundEndif: TokenSyntax = .poundEndifKeyword(), + _ unexpectedAfterPoundEndif: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2609,7 +2619,7 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenClausesAndPoundEndif, poundEndif, unexpectedAfterPoundEndif - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeClauses?.raw, clauses.raw, @@ -2618,12 +2628,13 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterPoundEndif?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifConfigDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.ifConfigDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2659,8 +2670,8 @@ public struct IfConfigDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.ifConfigClauseList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.ifConfigClauseList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return IfConfigDeclSyntax(newData) @@ -2711,8 +2722,8 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .importDecl else { - return nil + guard node.raw.kind == .importDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2726,18 +2737,18 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndImportTok: UnexpectedNodesSyntax? = nil, - importTok: TokenSyntax = .keyword(.import), - _ unexpectedBetweenImportTokAndImportKind: UnexpectedNodesSyntax? = nil, - importKind: TokenSyntax? = nil, - _ unexpectedBetweenImportKindAndPath: UnexpectedNodesSyntax? = nil, - path: AccessPathSyntax, - _ unexpectedAfterPath: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndImportTok: UnexpectedNodesSyntax? = nil, + importTok: TokenSyntax = .keyword(.import), + _ unexpectedBetweenImportTokAndImportKind: UnexpectedNodesSyntax? = nil, + importKind: TokenSyntax? = nil, + _ unexpectedBetweenImportKindAndPath: UnexpectedNodesSyntax? = nil, + path: AccessPathSyntax, + _ unexpectedAfterPath: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2755,7 +2766,7 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenImportKindAndPath, path, unexpectedAfterPath - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -2770,12 +2781,13 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterPath?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.importDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.importDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2811,8 +2823,8 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ImportDeclSyntax(newData) @@ -2848,8 +2860,8 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ImportDeclSyntax(newData) @@ -2921,8 +2933,8 @@ public struct ImportDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[9] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.accessPath, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.accessPath, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 9, with: collection, arena: arena) return ImportDeclSyntax(newData) @@ -2968,8 +2980,8 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .initializerDecl else { - return nil + guard node.raw.kind == .initializerDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2983,24 +2995,24 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndInitKeyword: UnexpectedNodesSyntax? = nil, - initKeyword: TokenSyntax = .keyword(.`init`), - _ unexpectedBetweenInitKeywordAndOptionalMark: UnexpectedNodesSyntax? = nil, - optionalMark: TokenSyntax? = nil, - _ unexpectedBetweenOptionalMarkAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndSignature: UnexpectedNodesSyntax? = nil, - signature: FunctionSignatureSyntax, - _ unexpectedBetweenSignatureAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax? = nil, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndInitKeyword: UnexpectedNodesSyntax? = nil, + initKeyword: TokenSyntax = .keyword(.`init`), + _ unexpectedBetweenInitKeywordAndOptionalMark: UnexpectedNodesSyntax? = nil, + optionalMark: TokenSyntax? = nil, + _ unexpectedBetweenOptionalMarkAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndSignature: UnexpectedNodesSyntax? = nil, + signature: FunctionSignatureSyntax, + _ unexpectedBetweenSignatureAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax? = nil, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3024,7 +3036,7 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -3045,12 +3057,13 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.initializerDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.initializerDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3087,8 +3100,8 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return InitializerDeclSyntax(newData) @@ -3125,8 +3138,8 @@ public struct InitializerDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return InitializerDeclSyntax(newData) @@ -3285,8 +3298,8 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .macroDecl else { - return nil + guard node.raw.kind == .macroDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3300,24 +3313,24 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndMacroKeyword: UnexpectedNodesSyntax? = nil, - macroKeyword: TokenSyntax = .keyword(.macro), - _ unexpectedBetweenMacroKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndSignature: UnexpectedNodesSyntax? = nil, - signature: FunctionSignatureSyntax, - _ unexpectedBetweenSignatureAndDefinition: UnexpectedNodesSyntax? = nil, - definition: InitializerClauseSyntax? = nil, - _ unexpectedBetweenDefinitionAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndMacroKeyword: UnexpectedNodesSyntax? = nil, + macroKeyword: TokenSyntax = .keyword(.macro), + _ unexpectedBetweenMacroKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndSignature: UnexpectedNodesSyntax? = nil, + signature: FunctionSignatureSyntax, + _ unexpectedBetweenSignatureAndDefinition: UnexpectedNodesSyntax? = nil, + definition: InitializerClauseSyntax? = nil, + _ unexpectedBetweenDefinitionAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3341,7 +3354,7 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenDefinitionAndGenericWhereClause, genericWhereClause, unexpectedAfterGenericWhereClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -3362,12 +3375,13 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.macroDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.macroDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3403,8 +3417,8 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return MacroDeclSyntax(newData) @@ -3440,8 +3454,8 @@ public struct MacroDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return MacroDeclSyntax(newData) @@ -3594,8 +3608,8 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .macroExpansionDecl else { - return nil + guard node.raw.kind == .macroExpansionDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3609,24 +3623,24 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundToken: UnexpectedNodesSyntax? = nil, - poundToken: TokenSyntax = .poundToken(), - _ unexpectedBetweenPoundTokenAndMacro: UnexpectedNodesSyntax? = nil, - macro: TokenSyntax, - _ unexpectedBetweenMacroAndGenericArguments: UnexpectedNodesSyntax? = nil, - genericArguments: GenericArgumentClauseSyntax? = nil, - _ unexpectedBetweenGenericArgumentsAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, - trailingClosure: ClosureExprSyntax? = nil, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, - additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, - _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePoundToken: UnexpectedNodesSyntax? = nil, + poundToken: TokenSyntax = .poundToken(), + _ unexpectedBetweenPoundTokenAndMacro: UnexpectedNodesSyntax? = nil, + macro: TokenSyntax, + _ unexpectedBetweenMacroAndGenericArguments: UnexpectedNodesSyntax? = nil, + genericArguments: GenericArgumentClauseSyntax? = nil, + _ unexpectedBetweenGenericArgumentsAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, + trailingClosure: ClosureExprSyntax? = nil, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, + _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3650,7 +3664,7 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, additionalTrailingClosures, unexpectedAfterAdditionalTrailingClosures - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePoundToken?.raw, poundToken.raw, @@ -3671,12 +3685,13 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterAdditionalTrailingClosures?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.macroExpansionDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.macroExpansionDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3785,8 +3800,8 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[9] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 9, with: collection, arena: arena) return MacroExpansionDeclSyntax(newData) @@ -3858,8 +3873,8 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[15] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 15, with: collection, arena: arena) return MacroExpansionDeclSyntax(newData) @@ -3899,13 +3914,13 @@ public struct MacroExpansionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { // MARK: - MissingDeclSyntax - +/// In case the source code is missing a declaration, this node stands in place of the missing declaration. public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .missingDecl else { - return nil + guard node.raw.kind == .missingDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3919,12 +3934,14 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedAfterModifiers: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndPlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedAfterPlaceholder: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3935,22 +3952,27 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { attributes, unexpectedBetweenAttributesAndModifiers, modifiers, - unexpectedAfterModifiers - ))) {(arena, _) in + unexpectedBetweenModifiersAndPlaceholder, + placeholder, + unexpectedAfterPlaceholder + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, unexpectedBetweenAttributesAndModifiers?.raw, modifiers?.raw, - unexpectedAfterModifiers?.raw + unexpectedBetweenModifiersAndPlaceholder?.raw, + placeholder.raw, + unexpectedAfterPlaceholder?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.missingDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.missingDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3965,6 +3987,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } + /// If there were standalone attributes without a declaration to attach them to, the `MissingDeclSyntax` will contain these. public var attributes: AttributeListSyntax? { get { return data.child(at: 1, parent: Syntax(self)).map(AttributeListSyntax.init) @@ -3986,8 +4009,8 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return MissingDeclSyntax(newData) @@ -4002,6 +4025,7 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } + /// If there were standalone modifiers without a declaration to attach them to, the `MissingDeclSyntax` will contain these. public var modifiers: ModifierListSyntax? { get { return data.child(at: 3, parent: Syntax(self)).map(ModifierListSyntax.init) @@ -4023,14 +4047,14 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return MissingDeclSyntax(newData) } - public var unexpectedAfterModifiers: UnexpectedNodesSyntax? { + public var unexpectedBetweenModifiersAndPlaceholder: UnexpectedNodesSyntax? { get { return data.child(at: 4, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -4039,13 +4063,34 @@ public struct MissingDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } + /// A placeholder, i.e. `<#decl#>` that can be inserted into the source code to represent the missing declaration./// This token should always have `presence = .missing`. + public var placeholder: TokenSyntax { + get { + return TokenSyntax(data.child(at: 5, parent: Syntax(self))!) + } + set(value) { + self = MissingDeclSyntax(data.replacingChild(at: 5, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterPlaceholder: UnexpectedNodesSyntax? { + get { + return data.child(at: 6, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MissingDeclSyntax(data.replacingChild(at: 6, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { return .layout([ \Self.unexpectedBeforeAttributes, \Self.attributes, \Self.unexpectedBetweenAttributesAndModifiers, \Self.modifiers, - \Self.unexpectedAfterModifiers + \Self.unexpectedBetweenModifiersAndPlaceholder, + \Self.placeholder, + \Self.unexpectedAfterPlaceholder ]) } } @@ -4057,8 +4102,8 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .operatorDecl else { - return nil + guard node.raw.kind == .operatorDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4072,18 +4117,18 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndOperatorKeyword: UnexpectedNodesSyntax? = nil, - operatorKeyword: TokenSyntax = .keyword(.operator), - _ unexpectedBetweenOperatorKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndOperatorPrecedenceAndTypes: UnexpectedNodesSyntax? = nil, - operatorPrecedenceAndTypes: OperatorPrecedenceAndTypesSyntax? = nil, - _ unexpectedAfterOperatorPrecedenceAndTypes: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndOperatorKeyword: UnexpectedNodesSyntax? = nil, + operatorKeyword: TokenSyntax = .keyword(.operator), + _ unexpectedBetweenOperatorKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndOperatorPrecedenceAndTypes: UnexpectedNodesSyntax? = nil, + operatorPrecedenceAndTypes: OperatorPrecedenceAndTypesSyntax? = nil, + _ unexpectedAfterOperatorPrecedenceAndTypes: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4101,7 +4146,7 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenIdentifierAndOperatorPrecedenceAndTypes, operatorPrecedenceAndTypes, unexpectedAfterOperatorPrecedenceAndTypes - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -4116,12 +4161,13 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterOperatorPrecedenceAndTypes?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.operatorDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.operatorDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4158,8 +4204,8 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return OperatorDeclSyntax(newData) @@ -4196,8 +4242,8 @@ public struct OperatorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return OperatorDeclSyntax(newData) @@ -4291,8 +4337,8 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundSourceLocation else { - return nil + guard node.raw.kind == .poundSourceLocation else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4306,16 +4352,16 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundSourceLocation: UnexpectedNodesSyntax? = nil, - poundSourceLocation: TokenSyntax = .poundSourceLocationKeyword(), - _ unexpectedBetweenPoundSourceLocationAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndArgs: UnexpectedNodesSyntax? = nil, - args: PoundSourceLocationArgsSyntax? = nil, - _ unexpectedBetweenArgsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePoundSourceLocation: UnexpectedNodesSyntax? = nil, + poundSourceLocation: TokenSyntax = .poundSourceLocationKeyword(), + _ unexpectedBetweenPoundSourceLocationAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndArgs: UnexpectedNodesSyntax? = nil, + args: PoundSourceLocationArgsSyntax? = nil, + _ unexpectedBetweenArgsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4331,7 +4377,7 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenArgsAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePoundSourceLocation?.raw, poundSourceLocation.raw, @@ -4344,12 +4390,13 @@ public struct PoundSourceLocationSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.poundSourceLocation, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.poundSourceLocation, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4458,8 +4505,8 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupDecl else { - return nil + guard node.raw.kind == .precedenceGroupDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4473,22 +4520,22 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndPrecedencegroupKeyword: UnexpectedNodesSyntax? = nil, - precedencegroupKeyword: TokenSyntax = .keyword(.precedencegroup), - _ unexpectedBetweenPrecedencegroupKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndGroupAttributes: UnexpectedNodesSyntax? = nil, - groupAttributes: PrecedenceGroupAttributeListSyntax, - _ unexpectedBetweenGroupAttributesAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndPrecedencegroupKeyword: UnexpectedNodesSyntax? = nil, + precedencegroupKeyword: TokenSyntax = .keyword(.precedencegroup), + _ unexpectedBetweenPrecedencegroupKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndGroupAttributes: UnexpectedNodesSyntax? = nil, + groupAttributes: PrecedenceGroupAttributeListSyntax, + _ unexpectedBetweenGroupAttributesAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4510,7 +4557,7 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGroupAttributesAndRightBrace, rightBrace, unexpectedAfterRightBrace - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -4529,12 +4576,13 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.precedenceGroupDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4571,8 +4619,8 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return PrecedenceGroupDeclSyntax(newData) @@ -4609,8 +4657,8 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return PrecedenceGroupDeclSyntax(newData) @@ -4702,8 +4750,8 @@ public struct PrecedenceGroupDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[11] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupAttributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupAttributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 11, with: collection, arena: arena) return PrecedenceGroupDeclSyntax(newData) @@ -4764,8 +4812,8 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .protocolDecl else { - return nil + guard node.raw.kind == .protocolDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4779,24 +4827,24 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil, - protocolKeyword: TokenSyntax = .keyword(.protocol), - _ unexpectedBetweenProtocolKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil, - primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil, - _ unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberDeclBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil, + protocolKeyword: TokenSyntax = .keyword(.protocol), + _ unexpectedBetweenProtocolKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil, + primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil, + _ unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberDeclBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4820,7 +4868,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock, unexpectedAfterMemberBlock - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -4841,12 +4889,13 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterMemberBlock?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.protocolDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.protocolDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4882,8 +4931,8 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ProtocolDeclSyntax(newData) @@ -4919,8 +4968,8 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ProtocolDeclSyntax(newData) @@ -5073,8 +5122,8 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .structDecl else { - return nil + guard node.raw.kind == .structDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5088,24 +5137,24 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil, - structKeyword: TokenSyntax = .keyword(.struct), - _ unexpectedBetweenStructKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, - inheritanceClause: TypeInheritanceClauseSyntax? = nil, - _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, - memberBlock: MemberDeclBlockSyntax, - _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil, + structKeyword: TokenSyntax = .keyword(.struct), + _ unexpectedBetweenStructKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil, + inheritanceClause: TypeInheritanceClauseSyntax? = nil, + _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil, + memberBlock: MemberDeclBlockSyntax, + _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5129,7 +5178,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndMemberBlock, memberBlock, unexpectedAfterMemberBlock - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -5150,12 +5199,13 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterMemberBlock?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.structDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.structDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5191,8 +5241,8 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return StructDeclSyntax(newData) @@ -5228,8 +5278,8 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return StructDeclSyntax(newData) @@ -5392,8 +5442,8 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: AccessorBlockSyntax) { @@ -5407,11 +5457,11 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(AccessorBlockSyntax.self) { self = .accessors(node) - return + return } if let node = node.as(CodeBlockSyntax.self) { self = .getter(node) - return + return } return nil } @@ -5424,8 +5474,8 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .subscriptDecl else { - return nil + guard node.raw.kind == .subscriptDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5439,24 +5489,24 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndSubscriptKeyword: UnexpectedNodesSyntax? = nil, - subscriptKeyword: TokenSyntax = .keyword(.subscript), - _ unexpectedBetweenSubscriptKeywordAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndIndices: UnexpectedNodesSyntax? = nil, - indices: ParameterClauseSyntax, - _ unexpectedBetweenIndicesAndResult: UnexpectedNodesSyntax? = nil, - result: ReturnClauseSyntax, - _ unexpectedBetweenResultAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndAccessor: UnexpectedNodesSyntax? = nil, - accessor: Accessor? = nil, - _ unexpectedAfterAccessor: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndSubscriptKeyword: UnexpectedNodesSyntax? = nil, + subscriptKeyword: TokenSyntax = .keyword(.subscript), + _ unexpectedBetweenSubscriptKeywordAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndIndices: UnexpectedNodesSyntax? = nil, + indices: ParameterClauseSyntax, + _ unexpectedBetweenIndicesAndResult: UnexpectedNodesSyntax? = nil, + result: ReturnClauseSyntax, + _ unexpectedBetweenResultAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndAccessor: UnexpectedNodesSyntax? = nil, + accessor: Accessor? = nil, + _ unexpectedAfterAccessor: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5480,7 +5530,7 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndAccessor, accessor, unexpectedAfterAccessor - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -5501,12 +5551,13 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterAccessor?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.subscriptDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.subscriptDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5542,8 +5593,8 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return SubscriptDeclSyntax(newData) @@ -5579,8 +5630,8 @@ public struct SubscriptDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return SubscriptDeclSyntax(newData) @@ -5733,8 +5784,8 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typealiasDecl else { - return nil + guard node.raw.kind == .typealiasDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5748,22 +5799,22 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndTypealiasKeyword: UnexpectedNodesSyntax? = nil, - typealiasKeyword: TokenSyntax = .keyword(.typealias), - _ unexpectedBetweenTypealiasKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, - genericParameterClause: GenericParameterClauseSyntax? = nil, - _ unexpectedBetweenGenericParameterClauseAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: TypeInitializerClauseSyntax, - _ unexpectedBetweenInitializerAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndTypealiasKeyword: UnexpectedNodesSyntax? = nil, + typealiasKeyword: TokenSyntax = .keyword(.typealias), + _ unexpectedBetweenTypealiasKeywordAndIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? = nil, + genericParameterClause: GenericParameterClauseSyntax? = nil, + _ unexpectedBetweenGenericParameterClauseAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: TypeInitializerClauseSyntax, + _ unexpectedBetweenInitializerAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5785,7 +5836,7 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenInitializerAndGenericWhereClause, genericWhereClause, unexpectedAfterGenericWhereClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -5804,12 +5855,13 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterGenericWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typealiasDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.typealiasDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5845,8 +5897,8 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return TypealiasDeclSyntax(newData) @@ -5882,8 +5934,8 @@ public struct TypealiasDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return TypealiasDeclSyntax(newData) @@ -6016,8 +6068,8 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .variableDecl else { - return nil + guard node.raw.kind == .variableDecl else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6031,16 +6083,16 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndBindingKeyword: UnexpectedNodesSyntax? = nil, - bindingKeyword: TokenSyntax, - _ unexpectedBetweenBindingKeywordAndBindings: UnexpectedNodesSyntax? = nil, - bindings: PatternBindingListSyntax, - _ unexpectedAfterBindings: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndBindingKeyword: UnexpectedNodesSyntax? = nil, + bindingKeyword: TokenSyntax, + _ unexpectedBetweenBindingKeywordAndBindings: UnexpectedNodesSyntax? = nil, + bindings: PatternBindingListSyntax, + _ unexpectedAfterBindings: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6056,7 +6108,7 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedBetweenBindingKeywordAndBindings, bindings, unexpectedAfterBindings - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -6069,12 +6121,13 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { unexpectedAfterBindings?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.variableDecl, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.variableDecl, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6110,8 +6163,8 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return VariableDeclSyntax(newData) @@ -6147,8 +6200,8 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return VariableDeclSyntax(newData) @@ -6202,8 +6255,8 @@ public struct VariableDeclSyntax: DeclSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[7] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.patternBindingList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.patternBindingList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 7, with: collection, arena: arena) return VariableDeclSyntax(newData) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift index 664bb1272b9..98dd79a1c38 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift @@ -19,8 +19,8 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .arrayExpr else { - return nil + guard node.raw.kind == .arrayExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -34,14 +34,14 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, - leftSquare: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftSquareAndElements: UnexpectedNodesSyntax? = nil, - elements: ArrayElementListSyntax, - _ unexpectedBetweenElementsAndRightSquare: UnexpectedNodesSyntax? = nil, - rightSquare: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareAndElements: UnexpectedNodesSyntax? = nil, + elements: ArrayElementListSyntax, + _ unexpectedBetweenElementsAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -55,7 +55,7 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenElementsAndRightSquare, rightSquare, unexpectedAfterRightSquare - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftSquare?.raw, leftSquare.raw, @@ -66,12 +66,13 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterRightSquare?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.arrayExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.arrayExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -125,8 +126,8 @@ public struct ArrayExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.arrayElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.arrayElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ArrayExprSyntax(newData) @@ -179,8 +180,8 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .arrowExpr else { - return nil + guard node.raw.kind == .arrowExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -194,12 +195,12 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndArrowToken: UnexpectedNodesSyntax? = nil, - arrowToken: TokenSyntax = .arrowToken(), - _ unexpectedAfterArrowToken: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndArrowToken: UnexpectedNodesSyntax? = nil, + arrowToken: TokenSyntax = .arrowToken(), + _ unexpectedAfterArrowToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -211,7 +212,7 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenEffectSpecifiersAndArrowToken, arrowToken, unexpectedAfterArrowToken - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeEffectSpecifiers?.raw, effectSpecifiers?.raw, @@ -220,12 +221,13 @@ public struct ArrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterArrowToken?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.arrowExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.arrowExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -294,8 +296,8 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .asExpr else { - return nil + guard node.raw.kind == .asExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -309,16 +311,16 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndAsTok: UnexpectedNodesSyntax? = nil, - asTok: TokenSyntax = .keyword(.as), - _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax? = nil, - _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: UnexpectedNodesSyntax? = nil, - typeName: T, - _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndAsTok: UnexpectedNodesSyntax? = nil, + asTok: TokenSyntax = .keyword(.as), + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax? = nil, + _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: UnexpectedNodesSyntax? = nil, + typeName: T, + _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -334,7 +336,7 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenQuestionOrExclamationMarkAndTypeName, typeName, unexpectedAfterTypeName - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -347,12 +349,13 @@ public struct AsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterTypeName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.asExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.asExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -461,8 +464,8 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .assignmentExpr else { - return nil + guard node.raw.kind == .assignmentExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -476,24 +479,25 @@ public struct AssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssignToken: UnexpectedNodesSyntax? = nil, - assignToken: TokenSyntax = .equalToken(), - _ unexpectedAfterAssignToken: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAssignToken: UnexpectedNodesSyntax? = nil, + assignToken: TokenSyntax = .equalToken(), + _ unexpectedAfterAssignToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssignToken, assignToken, unexpectedAfterAssignToken))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeAssignToken, assignToken, unexpectedAfterAssignToken))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeAssignToken?.raw, assignToken.raw, unexpectedAfterAssignToken?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.assignmentExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.assignmentExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -538,8 +542,8 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .awaitExpr else { - return nil + guard node.raw.kind == .awaitExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -553,12 +557,12 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAwaitKeyword: UnexpectedNodesSyntax? = nil, - awaitKeyword: TokenSyntax = .keyword(.await), - _ unexpectedBetweenAwaitKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAwaitKeyword: UnexpectedNodesSyntax? = nil, + awaitKeyword: TokenSyntax = .keyword(.await), + _ unexpectedBetweenAwaitKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -570,7 +574,7 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenAwaitKeywordAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAwaitKeyword?.raw, awaitKeyword.raw, @@ -579,12 +583,13 @@ public struct AwaitExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.awaitExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.awaitExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -653,8 +658,8 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .binaryOperatorExpr else { - return nil + guard node.raw.kind == .binaryOperatorExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -668,24 +673,25 @@ public struct BinaryOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, - operatorToken: TokenSyntax, - _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, + operatorToken: TokenSyntax, + _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeOperatorToken, operatorToken, unexpectedAfterOperatorToken))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeOperatorToken, operatorToken, unexpectedAfterOperatorToken))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeOperatorToken?.raw, operatorToken.raw, unexpectedAfterOperatorToken?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.binaryOperatorExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.binaryOperatorExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -730,8 +736,8 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .booleanLiteralExpr else { - return nil + guard node.raw.kind == .booleanLiteralExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -745,24 +751,25 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBooleanLiteral: UnexpectedNodesSyntax? = nil, - booleanLiteral: TokenSyntax, - _ unexpectedAfterBooleanLiteral: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBooleanLiteral: UnexpectedNodesSyntax? = nil, + booleanLiteral: TokenSyntax, + _ unexpectedAfterBooleanLiteral: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBooleanLiteral, booleanLiteral, unexpectedAfterBooleanLiteral))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeBooleanLiteral, booleanLiteral, unexpectedAfterBooleanLiteral))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeBooleanLiteral?.raw, booleanLiteral.raw, unexpectedAfterBooleanLiteral?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.booleanLiteralExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.booleanLiteralExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -807,8 +814,8 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .borrowExpr else { - return nil + guard node.raw.kind == .borrowExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -822,12 +829,12 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBorrowKeyword: UnexpectedNodesSyntax? = nil, - borrowKeyword: TokenSyntax = .keyword(._borrow), - _ unexpectedBetweenBorrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBorrowKeyword: UnexpectedNodesSyntax? = nil, + borrowKeyword: TokenSyntax = .keyword(._borrow), + _ unexpectedBetweenBorrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -839,7 +846,7 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenBorrowKeywordAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBorrowKeyword?.raw, borrowKeyword.raw, @@ -848,12 +855,13 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.borrowExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.borrowExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -922,8 +930,8 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureExpr else { - return nil + guard node.raw.kind == .closureExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -937,16 +945,16 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndSignature: UnexpectedNodesSyntax? = nil, - signature: ClosureSignatureSyntax? = nil, - _ unexpectedBetweenSignatureAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndSignature: UnexpectedNodesSyntax? = nil, + signature: ClosureSignatureSyntax? = nil, + _ unexpectedBetweenSignatureAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -962,7 +970,7 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenStatementsAndRightBrace, rightBrace, unexpectedAfterRightBrace - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftBrace?.raw, leftBrace.raw, @@ -975,12 +983,13 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1052,8 +1061,8 @@ public struct ClosureExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return ClosureExprSyntax(newData) @@ -1118,8 +1127,8 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: TokenSyntax) { @@ -1133,11 +1142,11 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(TokenSyntax.self) { self = .colon(node) - return + return } if let node = node.as(DictionaryElementListSyntax.self) { self = .elements(node) - return + return } return nil } @@ -1150,8 +1159,8 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dictionaryExpr else { - return nil + guard node.raw.kind == .dictionaryExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1165,14 +1174,14 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, - leftSquare: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftSquareAndContent: UnexpectedNodesSyntax? = nil, - content: Content, - _ unexpectedBetweenContentAndRightSquare: UnexpectedNodesSyntax? = nil, - rightSquare: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareAndContent: UnexpectedNodesSyntax? = nil, + content: Content, + _ unexpectedBetweenContentAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1186,7 +1195,7 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenContentAndRightSquare, rightSquare, unexpectedAfterRightSquare - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftSquare?.raw, leftSquare.raw, @@ -1197,12 +1206,13 @@ public struct DictionaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterRightSquare?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dictionaryExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.dictionaryExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1291,8 +1301,8 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .discardAssignmentExpr else { - return nil + guard node.raw.kind == .discardAssignmentExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1306,24 +1316,25 @@ public struct DiscardAssignmentExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWildcard: UnexpectedNodesSyntax? = nil, - wildcard: TokenSyntax = .wildcardToken(), - _ unexpectedAfterWildcard: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWildcard: UnexpectedNodesSyntax? = nil, + wildcard: TokenSyntax = .wildcardToken(), + _ unexpectedAfterWildcard: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWildcard, wildcard, unexpectedAfterWildcard))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeWildcard, wildcard, unexpectedAfterWildcard))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeWildcard?.raw, wildcard.raw, unexpectedAfterWildcard?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.discardAssignmentExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.discardAssignmentExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1368,8 +1379,8 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .editorPlaceholderExpr else { - return nil + guard node.raw.kind == .editorPlaceholderExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1383,24 +1394,25 @@ public struct EditorPlaceholderExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedAfterIdentifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedAfterIdentifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeIdentifier?.raw, identifier.raw, unexpectedAfterIdentifier?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.editorPlaceholderExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.editorPlaceholderExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1445,8 +1457,8 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .floatLiteralExpr else { - return nil + guard node.raw.kind == .floatLiteralExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1460,24 +1472,25 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? = nil, - floatingDigits: TokenSyntax, - _ unexpectedAfterFloatingDigits: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? = nil, + floatingDigits: TokenSyntax, + _ unexpectedAfterFloatingDigits: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFloatingDigits, floatingDigits, unexpectedAfterFloatingDigits))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFloatingDigits, floatingDigits, unexpectedAfterFloatingDigits))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeFloatingDigits?.raw, floatingDigits.raw, unexpectedAfterFloatingDigits?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.floatLiteralExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.floatLiteralExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1522,8 +1535,8 @@ public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .forcedValueExpr else { - return nil + guard node.raw.kind == .forcedValueExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1537,12 +1550,12 @@ public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndExclamationMark: UnexpectedNodesSyntax? = nil, - exclamationMark: TokenSyntax = .exclamationMarkToken(), - _ unexpectedAfterExclamationMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndExclamationMark: UnexpectedNodesSyntax? = nil, + exclamationMark: TokenSyntax = .exclamationMarkToken(), + _ unexpectedAfterExclamationMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1554,7 +1567,7 @@ public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndExclamationMark, exclamationMark, unexpectedAfterExclamationMark - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -1563,12 +1576,13 @@ public struct ForcedValueExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterExclamationMark?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.forcedValueExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.forcedValueExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1637,8 +1651,8 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionCallExpr else { - return nil + guard node.raw.kind == .functionCallExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1652,20 +1666,20 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, - calledExpression: C, - _ unexpectedBetweenCalledExpressionAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, - trailingClosure: ClosureExprSyntax? = nil, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, - additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, - _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, + calledExpression: C, + _ unexpectedBetweenCalledExpressionAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, + trailingClosure: ClosureExprSyntax? = nil, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, + _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1685,7 +1699,7 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, additionalTrailingClosures, unexpectedAfterAdditionalTrailingClosures - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeCalledExpression?.raw, calledExpression.raw, @@ -1702,12 +1716,13 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterAdditionalTrailingClosures?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionCallExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.functionCallExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1779,8 +1794,8 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return FunctionCallExprSyntax(newData) @@ -1852,8 +1867,8 @@ public struct FunctionCallExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[11] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 11, with: collection, arena: arena) return FunctionCallExprSyntax(newData) @@ -1894,8 +1909,8 @@ public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .identifierExpr else { - return nil + guard node.raw.kind == .identifierExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1909,12 +1924,12 @@ public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1926,7 +1941,7 @@ public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenIdentifierAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeIdentifier?.raw, identifier.raw, @@ -1935,12 +1950,13 @@ public struct IdentifierExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterDeclNameArguments?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.identifierExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.identifierExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2019,8 +2035,8 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: IfExprSyntax) { @@ -2034,11 +2050,11 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(IfExprSyntax.self) { self = .ifExpr(node) - return + return } if let node = node.as(CodeBlockSyntax.self) { self = .codeBlock(node) - return + return } return nil } @@ -2051,8 +2067,8 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ifExpr else { - return nil + guard node.raw.kind == .ifExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2066,18 +2082,18 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, - ifKeyword: TokenSyntax = .keyword(.if), - _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, - conditions: ConditionElementListSyntax, - _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, - elseKeyword: TokenSyntax? = nil, - _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, - elseBody: ElseBody? = nil, - _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIfKeyword: UnexpectedNodesSyntax? = nil, + ifKeyword: TokenSyntax = .keyword(.if), + _ unexpectedBetweenIfKeywordAndConditions: UnexpectedNodesSyntax? = nil, + conditions: ConditionElementListSyntax, + _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedBetweenBodyAndElseKeyword: UnexpectedNodesSyntax? = nil, + elseKeyword: TokenSyntax? = nil, + _ unexpectedBetweenElseKeywordAndElseBody: UnexpectedNodesSyntax? = nil, + elseBody: ElseBody? = nil, + _ unexpectedAfterElseBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2095,7 +2111,7 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenElseKeywordAndElseBody, elseBody, unexpectedAfterElseBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeIfKeyword?.raw, ifKeyword.raw, @@ -2110,12 +2126,13 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterElseBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.ifExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2169,8 +2186,8 @@ public struct IfExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return IfExprSyntax(newData) @@ -2263,8 +2280,8 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .inOutExpr else { - return nil + guard node.raw.kind == .inOutExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2278,12 +2295,12 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAmpersand: UnexpectedNodesSyntax? = nil, - ampersand: TokenSyntax = .prefixAmpersandToken(), - _ unexpectedBetweenAmpersandAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAmpersand: UnexpectedNodesSyntax? = nil, + ampersand: TokenSyntax = .prefixAmpersandToken(), + _ unexpectedBetweenAmpersandAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2295,7 +2312,7 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenAmpersandAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAmpersand?.raw, ampersand.raw, @@ -2304,12 +2321,13 @@ public struct InOutExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.inOutExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.inOutExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2378,8 +2396,8 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .infixOperatorExpr else { - return nil + guard node.raw.kind == .infixOperatorExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2393,14 +2411,14 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? = nil, - leftOperand: L, - _ unexpectedBetweenLeftOperandAndOperatorOperand: UnexpectedNodesSyntax? = nil, - operatorOperand: O, - _ unexpectedBetweenOperatorOperandAndRightOperand: UnexpectedNodesSyntax? = nil, - rightOperand: R, - _ unexpectedAfterRightOperand: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftOperand: UnexpectedNodesSyntax? = nil, + leftOperand: L, + _ unexpectedBetweenLeftOperandAndOperatorOperand: UnexpectedNodesSyntax? = nil, + operatorOperand: O, + _ unexpectedBetweenOperatorOperandAndRightOperand: UnexpectedNodesSyntax? = nil, + rightOperand: R, + _ unexpectedAfterRightOperand: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2414,7 +2432,7 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenOperatorOperandAndRightOperand, rightOperand, unexpectedAfterRightOperand - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftOperand?.raw, leftOperand.raw, @@ -2425,12 +2443,13 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterRightOperand?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.infixOperatorExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.infixOperatorExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2519,8 +2538,8 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .integerLiteralExpr else { - return nil + guard node.raw.kind == .integerLiteralExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2534,24 +2553,25 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDigits: UnexpectedNodesSyntax? = nil, - digits: TokenSyntax, - _ unexpectedAfterDigits: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDigits: UnexpectedNodesSyntax? = nil, + digits: TokenSyntax, + _ unexpectedAfterDigits: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDigits, digits, unexpectedAfterDigits))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeDigits, digits, unexpectedAfterDigits))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeDigits?.raw, digits.raw, unexpectedAfterDigits?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.integerLiteralExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.integerLiteralExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2596,8 +2616,8 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .isExpr else { - return nil + guard node.raw.kind == .isExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2611,14 +2631,14 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndIsTok: UnexpectedNodesSyntax? = nil, - isTok: TokenSyntax = .keyword(.is), - _ unexpectedBetweenIsTokAndTypeName: UnexpectedNodesSyntax? = nil, - typeName: T, - _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndIsTok: UnexpectedNodesSyntax? = nil, + isTok: TokenSyntax = .keyword(.is), + _ unexpectedBetweenIsTokAndTypeName: UnexpectedNodesSyntax? = nil, + typeName: T, + _ unexpectedAfterTypeName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2632,7 +2652,7 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenIsTokAndTypeName, typeName, unexpectedAfterTypeName - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -2643,12 +2663,13 @@ public struct IsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterTypeName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.isExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.isExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2737,8 +2758,8 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathExpr else { - return nil + guard node.raw.kind == .keyPathExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2752,14 +2773,14 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, - backslash: TokenSyntax = .backslashToken(), - _ unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? = nil, - root: R? = nil, - _ unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? = nil, - components: KeyPathComponentListSyntax, - _ unexpectedAfterComponents: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, + backslash: TokenSyntax = .backslashToken(), + _ unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? = nil, + root: R? = nil, + _ unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? = nil, + components: KeyPathComponentListSyntax, + _ unexpectedAfterComponents: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2773,7 +2794,7 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenRootAndComponents, components, unexpectedAfterComponents - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBackslash?.raw, backslash.raw, @@ -2784,12 +2805,13 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterComponents?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.keyPathExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2806,25 +2828,25 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, - backslash: TokenSyntax = .backslashToken(), - _ unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? = nil, - root: MissingTypeSyntax? = nil, - _ unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? = nil, - components: KeyPathComponentListSyntax, - _ unexpectedAfterComponents: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, + backslash: TokenSyntax = .backslashToken(), + _ unexpectedBetweenBackslashAndRoot: UnexpectedNodesSyntax? = nil, + root: MissingTypeSyntax? = nil, + _ unexpectedBetweenRootAndComponents: UnexpectedNodesSyntax? = nil, + components: KeyPathComponentListSyntax, + _ unexpectedAfterComponents: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeBackslash, - backslash: backslash, - unexpectedBetweenBackslashAndRoot, - root: Optional.none, - unexpectedBetweenRootAndComponents, - components: components, + leadingTrivia: leadingTrivia, + unexpectedBeforeBackslash, + backslash: backslash, + unexpectedBetweenBackslashAndRoot, + root: Optional.none, + unexpectedBetweenRootAndComponents, + components: components, unexpectedAfterComponents, trailingTrivia: trailingTrivia ) @@ -2896,8 +2918,8 @@ public struct KeyPathExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.keyPathComponentList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.keyPathComponentList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return KeyPathExprSyntax(newData) @@ -2932,8 +2954,8 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .macroExpansionExpr else { - return nil + guard node.raw.kind == .macroExpansionExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2947,24 +2969,24 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundToken: UnexpectedNodesSyntax? = nil, - poundToken: TokenSyntax = .poundToken(), - _ unexpectedBetweenPoundTokenAndMacro: UnexpectedNodesSyntax? = nil, - macro: TokenSyntax, - _ unexpectedBetweenMacroAndGenericArguments: UnexpectedNodesSyntax? = nil, - genericArguments: GenericArgumentClauseSyntax? = nil, - _ unexpectedBetweenGenericArgumentsAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, - trailingClosure: ClosureExprSyntax? = nil, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, - additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, - _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePoundToken: UnexpectedNodesSyntax? = nil, + poundToken: TokenSyntax = .poundToken(), + _ unexpectedBetweenPoundTokenAndMacro: UnexpectedNodesSyntax? = nil, + macro: TokenSyntax, + _ unexpectedBetweenMacroAndGenericArguments: UnexpectedNodesSyntax? = nil, + genericArguments: GenericArgumentClauseSyntax? = nil, + _ unexpectedBetweenGenericArgumentsAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedBetweenRightParenAndTrailingClosure: UnexpectedNodesSyntax? = nil, + trailingClosure: ClosureExprSyntax? = nil, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, + _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2988,7 +3010,7 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, additionalTrailingClosures, unexpectedAfterAdditionalTrailingClosures - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePoundToken?.raw, poundToken.raw, @@ -3009,12 +3031,13 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterAdditionalTrailingClosures?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.macroExpansionExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.macroExpansionExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3123,8 +3146,8 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[9] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 9, with: collection, arena: arena) return MacroExpansionExprSyntax(newData) @@ -3196,8 +3219,8 @@ public struct MacroExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[15] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 15, with: collection, arena: arena) return MacroExpansionExprSyntax(newData) @@ -3242,8 +3265,8 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberAccessExpr else { - return nil + guard node.raw.kind == .memberAccessExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3257,16 +3280,16 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, - base: B? = nil, - _ unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax = .periodToken(), - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, + base: B? = nil, + _ unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax = .periodToken(), + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3282,7 +3305,7 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBase?.raw, base?.raw, @@ -3295,12 +3318,13 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterDeclNameArguments?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberAccessExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.memberAccessExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3317,29 +3341,29 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, - base: MissingExprSyntax? = nil, - _ unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax = .periodToken(), - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, + base: MissingExprSyntax? = nil, + _ unexpectedBetweenBaseAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax = .periodToken(), + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeBase, - base: Optional.none, - unexpectedBetweenBaseAndDot, - dot: dot, - unexpectedBetweenDotAndName, - name: name, - unexpectedBetweenNameAndDeclNameArguments, - declNameArguments: declNameArguments, + leadingTrivia: leadingTrivia, + unexpectedBeforeBase, + base: Optional.none, + unexpectedBetweenBaseAndDot, + dot: dot, + unexpectedBetweenDotAndName, + name: name, + unexpectedBetweenNameAndDeclNameArguments, + declNameArguments: declNameArguments, unexpectedAfterDeclNameArguments, trailingTrivia: trailingTrivia ) @@ -3443,13 +3467,13 @@ public struct MemberAccessExprSyntax: ExprSyntaxProtocol, SyntaxHashable { // MARK: - MissingExprSyntax - +/// In case the source code is missing a expression, this node stands in place of the missing expression. public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .missingExpr else { - return nil + guard node.raw.kind == .missingExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3463,27 +3487,31 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpected: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedAfterPlaceholder: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) {(arena, _) in - let layout: [RawSyntax?] = [unexpected?.raw] + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) {(arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.missingExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.missingExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpected: UnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -3492,8 +3520,27 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } } + /// A placeholder, i.e. `<#expression#>` that can be inserted into the source code to represent the missing expression./// This token should always have `presence = .missing`. + public var placeholder: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = MissingExprSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterPlaceholder: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MissingExprSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { - return .layout([\Self.unexpected]) + return .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } } @@ -3504,8 +3551,8 @@ public struct MoveExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .moveExpr else { - return nil + guard node.raw.kind == .moveExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3519,12 +3566,12 @@ public struct MoveExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMoveKeyword: UnexpectedNodesSyntax? = nil, - moveKeyword: TokenSyntax, - _ unexpectedBetweenMoveKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeMoveKeyword: UnexpectedNodesSyntax? = nil, + moveKeyword: TokenSyntax, + _ unexpectedBetweenMoveKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3536,7 +3583,7 @@ public struct MoveExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenMoveKeywordAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeMoveKeyword?.raw, moveKeyword.raw, @@ -3545,12 +3592,13 @@ public struct MoveExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.moveExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.moveExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3619,8 +3667,8 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .nilLiteralExpr else { - return nil + guard node.raw.kind == .nilLiteralExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3634,24 +3682,25 @@ public struct NilLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeNilKeyword: UnexpectedNodesSyntax? = nil, - nilKeyword: TokenSyntax = .keyword(.nil), - _ unexpectedAfterNilKeyword: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeNilKeyword: UnexpectedNodesSyntax? = nil, + nilKeyword: TokenSyntax = .keyword(.nil), + _ unexpectedAfterNilKeyword: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeNilKeyword, nilKeyword, unexpectedAfterNilKeyword))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeNilKeyword, nilKeyword, unexpectedAfterNilKeyword))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeNilKeyword?.raw, nilKeyword.raw, unexpectedAfterNilKeyword?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.nilLiteralExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.nilLiteralExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3696,8 +3745,8 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .optionalChainingExpr else { - return nil + guard node.raw.kind == .optionalChainingExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3711,12 +3760,12 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax = .postfixQuestionMarkToken(), - _ unexpectedAfterQuestionMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax = .postfixQuestionMarkToken(), + _ unexpectedAfterQuestionMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3728,7 +3777,7 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndQuestionMark, questionMark, unexpectedAfterQuestionMark - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -3737,12 +3786,13 @@ public struct OptionalChainingExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterQuestionMark?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.optionalChainingExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.optionalChainingExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3811,8 +3861,8 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .packElementExpr else { - return nil + guard node.raw.kind == .packElementExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3826,12 +3876,12 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? = nil, - eachKeyword: TokenSyntax = .keyword(.each), - _ unexpectedBetweenEachKeywordAndPackRefExpr: UnexpectedNodesSyntax? = nil, - packRefExpr: P, - _ unexpectedAfterPackRefExpr: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? = nil, + eachKeyword: TokenSyntax = .keyword(.each), + _ unexpectedBetweenEachKeywordAndPackRefExpr: UnexpectedNodesSyntax? = nil, + packRefExpr: P, + _ unexpectedAfterPackRefExpr: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3843,7 +3893,7 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenEachKeywordAndPackRefExpr, packRefExpr, unexpectedAfterPackRefExpr - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeEachKeyword?.raw, eachKeyword.raw, @@ -3852,12 +3902,13 @@ public struct PackElementExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterPackRefExpr?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.packElementExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.packElementExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3926,8 +3977,8 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .packExpansionExpr else { - return nil + guard node.raw.kind == .packExpansionExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3941,12 +3992,12 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, - repeatKeyword: TokenSyntax = .keyword(.repeat), - _ unexpectedBetweenRepeatKeywordAndPatternExpr: UnexpectedNodesSyntax? = nil, - patternExpr: P, - _ unexpectedAfterPatternExpr: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, + repeatKeyword: TokenSyntax = .keyword(.repeat), + _ unexpectedBetweenRepeatKeywordAndPatternExpr: UnexpectedNodesSyntax? = nil, + patternExpr: P, + _ unexpectedAfterPatternExpr: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3958,7 +4009,7 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenRepeatKeywordAndPatternExpr, patternExpr, unexpectedAfterPatternExpr - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeRepeatKeyword?.raw, repeatKeyword.raw, @@ -3967,12 +4018,13 @@ public struct PackExpansionExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterPatternExpr?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.packExpansionExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.packExpansionExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4041,8 +4093,8 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .postfixIfConfigExpr else { - return nil + guard node.raw.kind == .postfixIfConfigExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4056,12 +4108,12 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, - base: B? = nil, - _ unexpectedBetweenBaseAndConfig: UnexpectedNodesSyntax? = nil, - config: IfConfigDeclSyntax, - _ unexpectedAfterConfig: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, + base: B? = nil, + _ unexpectedBetweenBaseAndConfig: UnexpectedNodesSyntax? = nil, + config: IfConfigDeclSyntax, + _ unexpectedAfterConfig: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4073,7 +4125,7 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenBaseAndConfig, config, unexpectedAfterConfig - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBase?.raw, base?.raw, @@ -4082,12 +4134,13 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterConfig?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.postfixIfConfigExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.postfixIfConfigExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4104,21 +4157,21 @@ public struct PostfixIfConfigExprSyntax: ExprSyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, - base: MissingExprSyntax? = nil, - _ unexpectedBetweenBaseAndConfig: UnexpectedNodesSyntax? = nil, - config: IfConfigDeclSyntax, - _ unexpectedAfterConfig: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBase: UnexpectedNodesSyntax? = nil, + base: MissingExprSyntax? = nil, + _ unexpectedBetweenBaseAndConfig: UnexpectedNodesSyntax? = nil, + config: IfConfigDeclSyntax, + _ unexpectedAfterConfig: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeBase, - base: Optional.none, - unexpectedBetweenBaseAndConfig, - config: config, + leadingTrivia: leadingTrivia, + unexpectedBeforeBase, + base: Optional.none, + unexpectedBetweenBaseAndConfig, + config: config, unexpectedAfterConfig, trailingTrivia: trailingTrivia ) @@ -4187,8 +4240,8 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .postfixUnaryExpr else { - return nil + guard node.raw.kind == .postfixUnaryExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4202,12 +4255,12 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndOperatorToken: UnexpectedNodesSyntax? = nil, - operatorToken: TokenSyntax, - _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndOperatorToken: UnexpectedNodesSyntax? = nil, + operatorToken: TokenSyntax, + _ unexpectedAfterOperatorToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4219,7 +4272,7 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndOperatorToken, operatorToken, unexpectedAfterOperatorToken - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -4228,12 +4281,13 @@ public struct PostfixUnaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterOperatorToken?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.postfixUnaryExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.postfixUnaryExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4302,8 +4356,8 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .prefixOperatorExpr else { - return nil + guard node.raw.kind == .prefixOperatorExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4317,12 +4371,12 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, - operatorToken: TokenSyntax? = nil, - _ unexpectedBetweenOperatorTokenAndPostfixExpression: UnexpectedNodesSyntax? = nil, - postfixExpression: P, - _ unexpectedAfterPostfixExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeOperatorToken: UnexpectedNodesSyntax? = nil, + operatorToken: TokenSyntax? = nil, + _ unexpectedBetweenOperatorTokenAndPostfixExpression: UnexpectedNodesSyntax? = nil, + postfixExpression: P, + _ unexpectedAfterPostfixExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4334,7 +4388,7 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenOperatorTokenAndPostfixExpression, postfixExpression, unexpectedAfterPostfixExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeOperatorToken?.raw, operatorToken?.raw, @@ -4343,12 +4397,13 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterPostfixExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.prefixOperatorExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.prefixOperatorExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4417,8 +4472,8 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .regexLiteralExpr else { - return nil + guard node.raw.kind == .regexLiteralExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4432,18 +4487,18 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOpeningPounds: UnexpectedNodesSyntax? = nil, - openingPounds: TokenSyntax? = nil, - _ unexpectedBetweenOpeningPoundsAndOpenSlash: UnexpectedNodesSyntax? = nil, - openSlash: TokenSyntax = .regexSlashToken(), - _ unexpectedBetweenOpenSlashAndRegexPattern: UnexpectedNodesSyntax? = nil, - regexPattern: TokenSyntax, - _ unexpectedBetweenRegexPatternAndCloseSlash: UnexpectedNodesSyntax? = nil, - closeSlash: TokenSyntax = .regexSlashToken(), - _ unexpectedBetweenCloseSlashAndClosingPounds: UnexpectedNodesSyntax? = nil, - closingPounds: TokenSyntax? = nil, - _ unexpectedAfterClosingPounds: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeOpeningPounds: UnexpectedNodesSyntax? = nil, + openingPounds: TokenSyntax? = nil, + _ unexpectedBetweenOpeningPoundsAndOpenSlash: UnexpectedNodesSyntax? = nil, + openSlash: TokenSyntax = .regexSlashToken(), + _ unexpectedBetweenOpenSlashAndRegexPattern: UnexpectedNodesSyntax? = nil, + regexPattern: TokenSyntax, + _ unexpectedBetweenRegexPatternAndCloseSlash: UnexpectedNodesSyntax? = nil, + closeSlash: TokenSyntax = .regexSlashToken(), + _ unexpectedBetweenCloseSlashAndClosingPounds: UnexpectedNodesSyntax? = nil, + closingPounds: TokenSyntax? = nil, + _ unexpectedAfterClosingPounds: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4461,7 +4516,7 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenCloseSlashAndClosingPounds, closingPounds, unexpectedAfterClosingPounds - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeOpeningPounds?.raw, openingPounds?.raw, @@ -4476,12 +4531,13 @@ public struct RegexLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterClosingPounds?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.regexLiteralExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.regexLiteralExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4610,8 +4666,8 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .sequenceExpr else { - return nil + guard node.raw.kind == .sequenceExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4625,24 +4681,25 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeElements: UnexpectedNodesSyntax? = nil, - elements: ExprListSyntax, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeElements: UnexpectedNodesSyntax? = nil, + elements: ExprListSyntax, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeElements, elements, unexpectedAfterElements))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeElements, elements, unexpectedAfterElements))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeElements?.raw, elements.raw, unexpectedAfterElements?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.sequenceExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.sequenceExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4678,8 +4735,8 @@ public struct SequenceExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.exprList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.exprList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return SequenceExprSyntax(newData) @@ -4706,8 +4763,8 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .specializeExpr else { - return nil + guard node.raw.kind == .specializeExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4721,12 +4778,12 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4738,7 +4795,7 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -4747,12 +4804,13 @@ public struct SpecializeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterGenericArgumentClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.specializeExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.specializeExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4821,8 +4879,8 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .stringLiteralExpr else { - return nil + guard node.raw.kind == .stringLiteralExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4836,18 +4894,18 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOpenDelimiter: UnexpectedNodesSyntax? = nil, - openDelimiter: TokenSyntax? = nil, - _ unexpectedBetweenOpenDelimiterAndOpenQuote: UnexpectedNodesSyntax? = nil, - openQuote: TokenSyntax, - _ unexpectedBetweenOpenQuoteAndSegments: UnexpectedNodesSyntax? = nil, - segments: StringLiteralSegmentsSyntax, - _ unexpectedBetweenSegmentsAndCloseQuote: UnexpectedNodesSyntax? = nil, - closeQuote: TokenSyntax, - _ unexpectedBetweenCloseQuoteAndCloseDelimiter: UnexpectedNodesSyntax? = nil, - closeDelimiter: TokenSyntax? = nil, - _ unexpectedAfterCloseDelimiter: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeOpenDelimiter: UnexpectedNodesSyntax? = nil, + openDelimiter: TokenSyntax? = nil, + _ unexpectedBetweenOpenDelimiterAndOpenQuote: UnexpectedNodesSyntax? = nil, + openQuote: TokenSyntax, + _ unexpectedBetweenOpenQuoteAndSegments: UnexpectedNodesSyntax? = nil, + segments: StringLiteralSegmentsSyntax, + _ unexpectedBetweenSegmentsAndCloseQuote: UnexpectedNodesSyntax? = nil, + closeQuote: TokenSyntax, + _ unexpectedBetweenCloseQuoteAndCloseDelimiter: UnexpectedNodesSyntax? = nil, + closeDelimiter: TokenSyntax? = nil, + _ unexpectedAfterCloseDelimiter: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4865,7 +4923,7 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenCloseQuoteAndCloseDelimiter, closeDelimiter, unexpectedAfterCloseDelimiter - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeOpenDelimiter?.raw, openDelimiter?.raw, @@ -4880,12 +4938,13 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterCloseDelimiter?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.stringLiteralExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.stringLiteralExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4957,8 +5016,8 @@ public struct StringLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralSegments, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.stringLiteralSegments, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return StringLiteralExprSyntax(newData) @@ -5033,8 +5092,8 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .subscriptExpr else { - return nil + guard node.raw.kind == .subscriptExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5048,20 +5107,20 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, - calledExpression: C, - _ unexpectedBetweenCalledExpressionAndLeftBracket: UnexpectedNodesSyntax? = nil, - leftBracket: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, - rightBracket: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedBetweenRightBracketAndTrailingClosure: UnexpectedNodesSyntax? = nil, - trailingClosure: ClosureExprSyntax? = nil, - _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, - additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, - _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeCalledExpression: UnexpectedNodesSyntax? = nil, + calledExpression: C, + _ unexpectedBetweenCalledExpressionAndLeftBracket: UnexpectedNodesSyntax? = nil, + leftBracket: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, + rightBracket: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedBetweenRightBracketAndTrailingClosure: UnexpectedNodesSyntax? = nil, + trailingClosure: ClosureExprSyntax? = nil, + _ unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, + additionalTrailingClosures: MultipleTrailingClosureElementListSyntax? = nil, + _ unexpectedAfterAdditionalTrailingClosures: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5081,7 +5140,7 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenTrailingClosureAndAdditionalTrailingClosures, additionalTrailingClosures, unexpectedAfterAdditionalTrailingClosures - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeCalledExpression?.raw, calledExpression.raw, @@ -5098,12 +5157,13 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterAdditionalTrailingClosures?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.subscriptExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.subscriptExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5175,8 +5235,8 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return SubscriptExprSyntax(newData) @@ -5248,8 +5308,8 @@ public struct SubscriptExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[11] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.multipleTrailingClosureElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 11, with: collection, arena: arena) return SubscriptExprSyntax(newData) @@ -5290,8 +5350,8 @@ public struct SuperRefExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .superRefExpr else { - return nil + guard node.raw.kind == .superRefExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5305,24 +5365,25 @@ public struct SuperRefExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSuperKeyword: UnexpectedNodesSyntax? = nil, - superKeyword: TokenSyntax = .keyword(.super), - _ unexpectedAfterSuperKeyword: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSuperKeyword: UnexpectedNodesSyntax? = nil, + superKeyword: TokenSyntax = .keyword(.super), + _ unexpectedAfterSuperKeyword: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSuperKeyword, superKeyword, unexpectedAfterSuperKeyword))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeSuperKeyword, superKeyword, unexpectedAfterSuperKeyword))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeSuperKeyword?.raw, superKeyword.raw, unexpectedAfterSuperKeyword?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.superRefExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.superRefExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5367,8 +5428,8 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchExpr else { - return nil + guard node.raw.kind == .switchExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5382,18 +5443,18 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, - switchKeyword: TokenSyntax = .keyword(.switch), - _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, - cases: SwitchCaseListSyntax, - _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSwitchKeyword: UnexpectedNodesSyntax? = nil, + switchKeyword: TokenSyntax = .keyword(.switch), + _ unexpectedBetweenSwitchKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndCases: UnexpectedNodesSyntax? = nil, + cases: SwitchCaseListSyntax, + _ unexpectedBetweenCasesAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5411,7 +5472,7 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenCasesAndRightBrace, rightBrace, unexpectedAfterRightBrace - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSwitchKeyword?.raw, switchKeyword.raw, @@ -5426,12 +5487,13 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.switchExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5521,8 +5583,8 @@ public struct SwitchExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[7] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.switchCaseList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 7, with: collection, arena: arena) return SwitchExprSyntax(newData) @@ -5579,8 +5641,8 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ternaryExpr else { - return nil + guard node.raw.kind == .ternaryExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5594,18 +5656,18 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? = nil, - conditionExpression: C, - _ unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax = .infixQuestionMarkToken(), - _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, - firstChoice: F, - _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, - colonMark: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? = nil, - secondChoice: S, - _ unexpectedAfterSecondChoice: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? = nil, + conditionExpression: C, + _ unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax = .infixQuestionMarkToken(), + _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, + firstChoice: F, + _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, + colonMark: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? = nil, + secondChoice: S, + _ unexpectedAfterSecondChoice: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5623,7 +5685,7 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenColonMarkAndSecondChoice, secondChoice, unexpectedAfterSecondChoice - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeConditionExpression?.raw, conditionExpression.raw, @@ -5638,12 +5700,13 @@ public struct TernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterSecondChoice?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ternaryExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.ternaryExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5772,8 +5835,8 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tryExpr else { - return nil + guard node.raw.kind == .tryExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5787,14 +5850,14 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeTryKeyword: UnexpectedNodesSyntax? = nil, - tryKeyword: TokenSyntax = .keyword(.try), - _ unexpectedBetweenTryKeywordAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax? = nil, - _ unexpectedBetweenQuestionOrExclamationMarkAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeTryKeyword: UnexpectedNodesSyntax? = nil, + tryKeyword: TokenSyntax = .keyword(.try), + _ unexpectedBetweenTryKeywordAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax? = nil, + _ unexpectedBetweenQuestionOrExclamationMarkAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5808,7 +5871,7 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenQuestionOrExclamationMarkAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeTryKeyword?.raw, tryKeyword.raw, @@ -5819,12 +5882,13 @@ public struct TryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tryExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tryExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5913,8 +5977,8 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tupleExpr else { - return nil + guard node.raw.kind == .tupleExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5928,14 +5992,14 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, - elementList: TupleExprElementListSyntax, - _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, + elementList: TupleExprElementListSyntax, + _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5949,7 +6013,7 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenElementListAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -5960,12 +6024,13 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tupleExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tupleExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6019,8 +6084,8 @@ public struct TupleExprSyntax: ExprSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return TupleExprSyntax(newData) @@ -6073,8 +6138,8 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeExpr else { - return nil + guard node.raw.kind == .typeExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6088,24 +6153,25 @@ public struct TypeExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedAfterType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedAfterType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeType, type, unexpectedAfterType))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeType, type, unexpectedAfterType))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeType?.raw, type.raw, unexpectedAfterType?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.typeExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6150,8 +6216,8 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unresolvedAsExpr else { - return nil + guard node.raw.kind == .unresolvedAsExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6165,12 +6231,12 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAsTok: UnexpectedNodesSyntax? = nil, - asTok: TokenSyntax = .keyword(.as), - _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax? = nil, - _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAsTok: UnexpectedNodesSyntax? = nil, + asTok: TokenSyntax = .keyword(.as), + _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax? = nil, + _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6182,7 +6248,7 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenAsTokAndQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsTok?.raw, asTok.raw, @@ -6191,12 +6257,13 @@ public struct UnresolvedAsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterQuestionOrExclamationMark?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unresolvedAsExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.unresolvedAsExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6265,8 +6332,8 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unresolvedIsExpr else { - return nil + guard node.raw.kind == .unresolvedIsExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6280,24 +6347,25 @@ public struct UnresolvedIsExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIsTok: UnexpectedNodesSyntax? = nil, - isTok: TokenSyntax = .keyword(.is), - _ unexpectedAfterIsTok: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIsTok: UnexpectedNodesSyntax? = nil, + isTok: TokenSyntax = .keyword(.is), + _ unexpectedAfterIsTok: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIsTok, isTok, unexpectedAfterIsTok))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIsTok, isTok, unexpectedAfterIsTok))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeIsTok?.raw, isTok.raw, unexpectedAfterIsTok?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unresolvedIsExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.unresolvedIsExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6342,8 +6410,8 @@ public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unresolvedPatternExpr else { - return nil + guard node.raw.kind == .unresolvedPatternExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6357,24 +6425,25 @@ public struct UnresolvedPatternExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedAfterPattern: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedAfterPattern: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedAfterPattern))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePattern, pattern, unexpectedAfterPattern))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforePattern?.raw, pattern.raw, unexpectedAfterPattern?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unresolvedPatternExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.unresolvedPatternExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6419,8 +6488,8 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unresolvedTernaryExpr else { - return nil + guard node.raw.kind == .unresolvedTernaryExpr else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6434,14 +6503,14 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax = .infixQuestionMarkToken(), - _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, - firstChoice: F, - _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, - colonMark: TokenSyntax = .colonToken(), - _ unexpectedAfterColonMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax = .infixQuestionMarkToken(), + _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, + firstChoice: F, + _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, + colonMark: TokenSyntax = .colonToken(), + _ unexpectedAfterColonMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6455,7 +6524,7 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedBetweenFirstChoiceAndColonMark, colonMark, unexpectedAfterColonMark - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeQuestionMark?.raw, questionMark.raw, @@ -6466,12 +6535,13 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable { unexpectedAfterColonMark?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unresolvedTernaryExpr, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.unresolvedTernaryExpr, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift index 86d97e15318..686a7d1e6ff 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodes.swift @@ -19,8 +19,8 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessPathComponent else { - return nil + guard node.raw.kind == .accessPathComponent else { + return nil } self._syntaxNode = node._syntaxNode } @@ -34,12 +34,12 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, - trailingDot: TokenSyntax? = nil, - _ unexpectedAfterTrailingDot: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingDot: UnexpectedNodesSyntax? = nil, + trailingDot: TokenSyntax? = nil, + _ unexpectedAfterTrailingDot: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -51,7 +51,7 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndTrailingDot, trailingDot, unexpectedAfterTrailingDot - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -60,12 +60,13 @@ public struct AccessPathComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingDot?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessPathComponent, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.accessPathComponent, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -134,8 +135,8 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorBlock else { - return nil + guard node.raw.kind == .accessorBlock else { + return nil } self._syntaxNode = node._syntaxNode } @@ -149,14 +150,14 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? = nil, - accessors: AccessorListSyntax, - _ unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndAccessors: UnexpectedNodesSyntax? = nil, + accessors: AccessorListSyntax, + _ unexpectedBetweenAccessorsAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -170,7 +171,7 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAccessorsAndRightBrace, rightBrace, unexpectedAfterRightBrace - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftBrace?.raw, leftBrace.raw, @@ -181,12 +182,13 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorBlock, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.accessorBlock, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -240,8 +242,8 @@ public struct AccessorBlockSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.accessorList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.accessorList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return AccessorBlockSyntax(newData) @@ -294,8 +296,8 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorEffectSpecifiers else { - return nil + guard node.raw.kind == .accessorEffectSpecifiers else { + return nil } self._syntaxNode = node._syntaxNode } @@ -309,12 +311,12 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, - asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, + asyncSpecifier: TokenSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -326,7 +328,7 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, unexpectedAfterThrowsSpecifier - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, @@ -335,12 +337,13 @@ public struct AccessorEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterThrowsSpecifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorEffectSpecifiers, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.accessorEffectSpecifiers, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -409,8 +412,8 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .accessorParameter else { - return nil + guard node.raw.kind == .accessorParameter else { + return nil } self._syntaxNode = node._syntaxNode } @@ -424,14 +427,14 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -445,7 +448,7 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -456,12 +459,13 @@ public struct AccessorParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.accessorParameter, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.accessorParameter, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -550,8 +554,8 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .arrayElement else { - return nil + guard node.raw.kind == .arrayElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -565,12 +569,12 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -582,7 +586,7 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -591,12 +595,13 @@ public struct ArrayElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.arrayElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.arrayElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -729,8 +734,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: TupleExprElementListSyntax) { @@ -816,83 +821,83 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(TupleExprElementListSyntax.self) { self = .argumentList(node) - return + return } if let node = node.as(TokenSyntax.self) { self = .token(node) - return + return } if let node = node.as(StringLiteralExprSyntax.self) { self = .string(node) - return + return } if let node = node.as(AvailabilitySpecListSyntax.self) { self = .availability(node) - return + return } if let node = node.as(SpecializeAttributeSpecListSyntax.self) { self = .specializeArguments(node) - return + return } if let node = node.as(ObjCSelectorSyntax.self) { self = .objCName(node) - return + return } if let node = node.as(ImplementsAttributeArgumentsSyntax.self) { self = .implementsArguments(node) - return + return } if let node = node.as(DifferentiableAttributeArgumentsSyntax.self) { self = .differentiableArguments(node) - return + return } if let node = node.as(DerivativeRegistrationAttributeArgumentsSyntax.self) { self = .derivativeRegistrationArguments(node) - return + return } if let node = node.as(BackDeployedAttributeSpecListSyntax.self) { self = .backDeployedArguments(node) - return + return } if let node = node.as(ConventionAttributeArgumentsSyntax.self) { self = .conventionArguments(node) - return + return } if let node = node.as(ConventionWitnessMethodAttributeArgumentsSyntax.self) { self = .conventionWitnessMethodArguments(node) - return + return } if let node = node.as(OpaqueReturnTypeOfAttributeArgumentsSyntax.self) { self = .opaqueReturnTypeOfAttributeArguments(node) - return + return } if let node = node.as(ExposeAttributeArgumentsSyntax.self) { self = .exposeAttributeArguments(node) - return + return } if let node = node.as(OriginallyDefinedInArgumentsSyntax.self) { self = .originallyDefinedInArguments(node) - return + return } if let node = node.as(UnderscorePrivateAttributeArgumentsSyntax.self) { self = .underscorePrivateAttributeArguments(node) - return + return } if let node = node.as(DynamicReplacementArgumentsSyntax.self) { self = .dynamicReplacementArguments(node) - return + return } if let node = node.as(UnavailableFromAsyncArgumentsSyntax.self) { self = .unavailableFromAsyncArguments(node) - return + return } if let node = node.as(EffectsArgumentsSyntax.self) { self = .effectsArguments(node) - return + return } if let node = node.as(DocumentationAttributeArgumentsSyntax.self) { self = .documentationArguments(node) - return + return } return nil } @@ -926,8 +931,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .attribute else { - return nil + guard node.raw.kind == .attribute else { + return nil } self._syntaxNode = node._syntaxNode } @@ -941,18 +946,18 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, - atSignToken: TokenSyntax = .atSignToken(), - _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, - attributeName: A, - _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, - argument: Argument? = nil, - _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAtSignToken: UnexpectedNodesSyntax? = nil, + atSignToken: TokenSyntax = .atSignToken(), + _ unexpectedBetweenAtSignTokenAndAttributeName: UnexpectedNodesSyntax? = nil, + attributeName: A, + _ unexpectedBetweenAttributeNameAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndArgument: UnexpectedNodesSyntax? = nil, + argument: Argument? = nil, + _ unexpectedBetweenArgumentAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -970,7 +975,7 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenArgumentAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAtSignToken?.raw, atSignToken.raw, @@ -985,12 +990,13 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.attribute, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.attribute, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1137,8 +1143,8 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: TokenSyntax) { @@ -1156,15 +1162,15 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(TokenSyntax.self) { self = .token(node) - return + return } if let node = node.as(AvailabilityVersionRestrictionSyntax.self) { self = .availabilityVersionRestriction(node) - return + return } if let node = node.as(AvailabilityLabeledArgumentSyntax.self) { self = .availabilityLabeledArgument(node) - return + return } return nil } @@ -1177,8 +1183,8 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityArgument else { - return nil + guard node.raw.kind == .availabilityArgument else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1192,12 +1198,12 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEntry: UnexpectedNodesSyntax? = nil, - entry: Entry, - _ unexpectedBetweenEntryAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEntry: UnexpectedNodesSyntax? = nil, + entry: Entry, + _ unexpectedBetweenEntryAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1209,7 +1215,7 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenEntryAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeEntry?.raw, entry.raw, @@ -1218,12 +1224,13 @@ public struct AvailabilityArgumentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityArgument, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.availabilityArgument, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1294,8 +1301,8 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityCondition else { - return nil + guard node.raw.kind == .availabilityCondition else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1309,16 +1316,16 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, - availabilityKeyword: TokenSyntax, - _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, - availabilitySpec: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAvailabilityKeyword: UnexpectedNodesSyntax? = nil, + availabilityKeyword: TokenSyntax, + _ unexpectedBetweenAvailabilityKeywordAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndAvailabilitySpec: UnexpectedNodesSyntax? = nil, + availabilitySpec: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilitySpecAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1334,7 +1341,7 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAvailabilitySpecAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAvailabilityKeyword?.raw, availabilityKeyword.raw, @@ -1347,12 +1354,13 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityCondition, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.availabilityCondition, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1424,8 +1432,8 @@ public struct AvailabilityConditionSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return AvailabilityConditionSyntax(newData) @@ -1480,8 +1488,8 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityEntry else { - return nil + guard node.raw.kind == .availabilityEntry else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1495,16 +1503,16 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax = .keyword(.availability), - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, - availabilityList: AvailabilitySpecListSyntax, - _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax = .semicolonToken(), - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax = .keyword(.availability), + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndAvailabilityList: UnexpectedNodesSyntax? = nil, + availabilityList: AvailabilitySpecListSyntax, + _ unexpectedBetweenAvailabilityListAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax = .semicolonToken(), + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1520,7 +1528,7 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAvailabilityListAndSemicolon, semicolon, unexpectedAfterSemicolon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, @@ -1533,12 +1541,13 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterSemicolon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityEntry, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.availabilityEntry, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1612,8 +1621,8 @@ public struct AvailabilityEntrySyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilitySpecList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return AvailabilityEntrySyntax(newData) @@ -1678,8 +1687,8 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: StringLiteralExprSyntax) { @@ -1693,11 +1702,11 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable public init?(_ node: S) { if let node = node.as(StringLiteralExprSyntax.self) { self = .string(node) - return + return } if let node = node.as(VersionTupleSyntax.self) { self = .version(node) - return + return } return nil } @@ -1710,8 +1719,8 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityLabeledArgument else { - return nil + guard node.raw.kind == .availabilityLabeledArgument else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1725,14 +1734,14 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: Value, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: Value, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1746,7 +1755,7 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenColonAndValue, value, unexpectedAfterValue - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, @@ -1757,12 +1766,13 @@ public struct AvailabilityLabeledArgumentSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterValue?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityLabeledArgument, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.availabilityLabeledArgument, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1854,8 +1864,8 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityVersionRestrictionListEntry else { - return nil + guard node.raw.kind == .availabilityVersionRestrictionListEntry else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1869,12 +1879,12 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, - availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, - _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAvailabilityVersionRestriction: UnexpectedNodesSyntax? = nil, + availabilityVersionRestriction: AvailabilityVersionRestrictionSyntax, + _ unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1886,7 +1896,7 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn unexpectedBetweenAvailabilityVersionRestrictionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAvailabilityVersionRestriction?.raw, availabilityVersionRestriction.raw, @@ -1895,12 +1905,13 @@ public struct AvailabilityVersionRestrictionListEntrySyntax: SyntaxProtocol, Syn unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityVersionRestrictionListEntry, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.availabilityVersionRestrictionListEntry, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1970,8 +1981,8 @@ public struct AvailabilityVersionRestrictionSyntax: SyntaxProtocol, SyntaxHashab public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .availabilityVersionRestriction else { - return nil + guard node.raw.kind == .availabilityVersionRestriction else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1985,12 +1996,12 @@ public struct AvailabilityVersionRestrictionSyntax: SyntaxProtocol, SyntaxHashab } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePlatform: UnexpectedNodesSyntax? = nil, - platform: TokenSyntax, - _ unexpectedBetweenPlatformAndVersion: UnexpectedNodesSyntax? = nil, - version: VersionTupleSyntax? = nil, - _ unexpectedAfterVersion: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePlatform: UnexpectedNodesSyntax? = nil, + platform: TokenSyntax, + _ unexpectedBetweenPlatformAndVersion: UnexpectedNodesSyntax? = nil, + version: VersionTupleSyntax? = nil, + _ unexpectedAfterVersion: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2002,7 +2013,7 @@ public struct AvailabilityVersionRestrictionSyntax: SyntaxProtocol, SyntaxHashab unexpectedBetweenPlatformAndVersion, version, unexpectedAfterVersion - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePlatform?.raw, platform.raw, @@ -2011,12 +2022,13 @@ public struct AvailabilityVersionRestrictionSyntax: SyntaxProtocol, SyntaxHashab unexpectedAfterVersion?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.availabilityVersionRestriction, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.availabilityVersionRestriction, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2086,8 +2098,8 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .backDeployedAttributeSpecList else { - return nil + guard node.raw.kind == .backDeployedAttributeSpecList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2101,14 +2113,14 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, - beforeLabel: TokenSyntax = .keyword(.before), - _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, - versionList: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBeforeLabel: UnexpectedNodesSyntax? = nil, + beforeLabel: TokenSyntax = .keyword(.before), + _ unexpectedBetweenBeforeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndVersionList: UnexpectedNodesSyntax? = nil, + versionList: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterVersionList: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2122,7 +2134,7 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl unexpectedBetweenColonAndVersionList, versionList, unexpectedAfterVersionList - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBeforeLabel?.raw, beforeLabel.raw, @@ -2133,12 +2145,13 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl unexpectedAfterVersionList?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.backDeployedAttributeSpecList, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.backDeployedAttributeSpecList, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2213,8 +2226,8 @@ public struct BackDeployedAttributeSpecListSyntax: SyntaxProtocol, SyntaxHashabl if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return BackDeployedAttributeSpecListSyntax(newData) @@ -2249,8 +2262,8 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .caseItem else { - return nil + guard node.raw.kind == .caseItem else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2264,14 +2277,14 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2285,7 +2298,7 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePattern?.raw, pattern.raw, @@ -2296,12 +2309,13 @@ public struct CaseItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.caseItem, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.caseItem, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2390,8 +2404,8 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .catchClause else { - return nil + guard node.raw.kind == .catchClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2405,14 +2419,14 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCatchKeyword: UnexpectedNodesSyntax? = nil, - catchKeyword: TokenSyntax = .keyword(.catch), - _ unexpectedBetweenCatchKeywordAndCatchItems: UnexpectedNodesSyntax? = nil, - catchItems: CatchItemListSyntax? = nil, - _ unexpectedBetweenCatchItemsAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeCatchKeyword: UnexpectedNodesSyntax? = nil, + catchKeyword: TokenSyntax = .keyword(.catch), + _ unexpectedBetweenCatchKeywordAndCatchItems: UnexpectedNodesSyntax? = nil, + catchItems: CatchItemListSyntax? = nil, + _ unexpectedBetweenCatchItemsAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2426,7 +2440,7 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenCatchItemsAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeCatchKeyword?.raw, catchKeyword.raw, @@ -2437,12 +2451,13 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.catchClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.catchClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2496,8 +2511,8 @@ public struct CatchClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.catchItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.catchItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return CatchClauseSyntax(newData) @@ -2550,8 +2565,8 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .catchItem else { - return nil + guard node.raw.kind == .catchItem else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2565,14 +2580,14 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P? = nil, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P? = nil, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2586,7 +2601,7 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenWhereClauseAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePattern?.raw, pattern?.raw, @@ -2597,12 +2612,13 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.catchItem, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.catchItem, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2619,25 +2635,25 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: MissingPatternSyntax? = nil, - _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: MissingPatternSyntax? = nil, + _ unexpectedBetweenPatternAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforePattern, - pattern: Optional.none, - unexpectedBetweenPatternAndWhereClause, - whereClause: whereClause, - unexpectedBetweenWhereClauseAndTrailingComma, - trailingComma: trailingComma, + leadingTrivia: leadingTrivia, + unexpectedBeforePattern, + pattern: Optional.none, + unexpectedBetweenPatternAndWhereClause, + whereClause: whereClause, + unexpectedBetweenWhereClauseAndTrailingComma, + trailingComma: trailingComma, unexpectedAfterTrailingComma, trailingTrivia: trailingTrivia ) @@ -2726,8 +2742,8 @@ public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureItemSpecifier else { - return nil + guard node.raw.kind == .closureCaptureItemSpecifier else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2741,16 +2757,16 @@ public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: TokenSyntax, - _ unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, - detail: TokenSyntax? = nil, - _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, + specifier: TokenSyntax, + _ unexpectedBetweenSpecifierAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, + detail: TokenSyntax? = nil, + _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2766,7 +2782,7 @@ public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSpecifier?.raw, specifier.raw, @@ -2779,12 +2795,13 @@ public struct ClosureCaptureItemSpecifierSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureItemSpecifier, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureCaptureItemSpecifier, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2893,8 +2910,8 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureItem else { - return nil + guard node.raw.kind == .closureCaptureItem else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2908,18 +2925,18 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: ClosureCaptureItemSpecifierSyntax? = nil, - _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax? = nil, - _ unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? = nil, - assignToken: TokenSyntax? = nil, - _ unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, + specifier: ClosureCaptureItemSpecifierSyntax? = nil, + _ unexpectedBetweenSpecifierAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndAssignToken: UnexpectedNodesSyntax? = nil, + assignToken: TokenSyntax? = nil, + _ unexpectedBetweenAssignTokenAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2937,7 +2954,7 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSpecifier?.raw, specifier?.raw, @@ -2952,12 +2969,13 @@ public struct ClosureCaptureItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureItem, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureCaptureItem, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3086,8 +3104,8 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureCaptureSignature else { - return nil + guard node.raw.kind == .closureCaptureSignature else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3101,14 +3119,14 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, - leftSquare: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? = nil, - items: ClosureCaptureItemListSyntax? = nil, - _ unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? = nil, - rightSquare: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftSquare: UnexpectedNodesSyntax? = nil, + leftSquare: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareAndItems: UnexpectedNodesSyntax? = nil, + items: ClosureCaptureItemListSyntax? = nil, + _ unexpectedBetweenItemsAndRightSquare: UnexpectedNodesSyntax? = nil, + rightSquare: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquare: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3122,7 +3140,7 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenItemsAndRightSquare, rightSquare, unexpectedAfterRightSquare - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftSquare?.raw, leftSquare.raw, @@ -3133,12 +3151,13 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightSquare?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureCaptureSignature, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureCaptureSignature, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3192,8 +3211,8 @@ public struct ClosureCaptureSignatureSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.closureCaptureItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.closureCaptureItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ClosureCaptureSignatureSyntax(newData) @@ -3246,8 +3265,8 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureParam else { - return nil + guard node.raw.kind == .closureParam else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3261,12 +3280,12 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3278,7 +3297,7 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -3287,12 +3306,13 @@ public struct ClosureParamSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureParam, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureParam, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3361,8 +3381,8 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureParameterClause else { - return nil + guard node.raw.kind == .closureParameterClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3376,14 +3396,14 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, - parameterList: ClosureParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, + parameterList: ClosureParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3397,7 +3417,7 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenParameterListAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -3408,12 +3428,13 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureParameterClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureParameterClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3469,8 +3490,8 @@ public struct ClosureParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.closureParameterList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ClosureParameterClauseSyntax(newData) @@ -3524,8 +3545,8 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureParameter else { - return nil + guard node.raw.kind == .closureParameter else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3539,24 +3560,24 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, - firstName: TokenSyntax, - _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, - secondName: TokenSyntax? = nil, - _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: T? = nil, - _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, - ellipsis: TokenSyntax? = nil, - _ unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T? = nil, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3580,7 +3601,7 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenEllipsisAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -3601,12 +3622,13 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureParameter, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureParameter, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -3623,45 +3645,45 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, - firstName: TokenSyntax, - _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, - secondName: TokenSyntax? = nil, - _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: MissingTypeSyntax? = nil, - _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, - ellipsis: TokenSyntax? = nil, - _ unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: MissingTypeSyntax? = nil, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndModifiers, - modifiers: modifiers, - unexpectedBetweenModifiersAndFirstName, - firstName: firstName, - unexpectedBetweenFirstNameAndSecondName, - secondName: secondName, - unexpectedBetweenSecondNameAndColon, - colon: colon, - unexpectedBetweenColonAndType, - type: Optional.none, - unexpectedBetweenTypeAndEllipsis, - ellipsis: ellipsis, - unexpectedBetweenEllipsisAndTrailingComma, - trailingComma: trailingComma, + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndModifiers, + modifiers: modifiers, + unexpectedBetweenModifiersAndFirstName, + firstName: firstName, + unexpectedBetweenFirstNameAndSecondName, + secondName: secondName, + unexpectedBetweenSecondNameAndColon, + colon: colon, + unexpectedBetweenColonAndType, + type: Optional.none, + unexpectedBetweenTypeAndEllipsis, + ellipsis: ellipsis, + unexpectedBetweenEllipsisAndTrailingComma, + trailingComma: trailingComma, unexpectedAfterTrailingComma, trailingTrivia: trailingTrivia ) @@ -3697,8 +3719,8 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ClosureParameterSyntax(newData) @@ -3734,8 +3756,8 @@ public struct ClosureParameterSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ClosureParameterSyntax(newData) @@ -3904,8 +3926,8 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: ClosureParamListSyntax) { @@ -3919,11 +3941,11 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(ClosureParamListSyntax.self) { self = .simpleInput(node) - return + return } if let node = node.as(ClosureParameterClauseSyntax.self) { self = .input(node) - return + return } return nil } @@ -3936,8 +3958,8 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .closureSignature else { - return nil + guard node.raw.kind == .closureSignature else { + return nil } self._syntaxNode = node._syntaxNode } @@ -3951,20 +3973,20 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, - capture: ClosureCaptureSignatureSyntax? = nil, - _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, - input: Input? = nil, - _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, - inTok: TokenSyntax = .keyword(.in), - _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndCapture: UnexpectedNodesSyntax? = nil, + capture: ClosureCaptureSignatureSyntax? = nil, + _ unexpectedBetweenCaptureAndInput: UnexpectedNodesSyntax? = nil, + input: Input? = nil, + _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax? = nil, + _ unexpectedBetweenOutputAndInTok: UnexpectedNodesSyntax? = nil, + inTok: TokenSyntax = .keyword(.in), + _ unexpectedAfterInTok: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -3984,7 +4006,7 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenOutputAndInTok, inTok, unexpectedAfterInTok - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -4001,12 +4023,13 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterInTok?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.closureSignature, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.closureSignature, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4042,8 +4065,8 @@ public struct ClosureSignatureSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return ClosureSignatureSyntax(newData) @@ -4187,8 +4210,8 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: Node) { @@ -4206,15 +4229,15 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(DeclSyntax.self) { self = .decl(node) - return + return } if let node = node.as(StmtSyntax.self) { self = .stmt(node) - return + return } if let node = node.as(ExprSyntax.self) { self = .expr(node) - return + return } return nil } @@ -4227,8 +4250,8 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .codeBlockItem else { - return nil + guard node.raw.kind == .codeBlockItem else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4242,12 +4265,12 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeItem: UnexpectedNodesSyntax? = nil, - item: Item, - _ unexpectedBetweenItemAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax? = nil, - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeItem: UnexpectedNodesSyntax? = nil, + item: Item, + _ unexpectedBetweenItemAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax? = nil, + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4259,7 +4282,7 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenItemAndSemicolon, semicolon, unexpectedAfterSemicolon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeItem?.raw, item.raw, @@ -4268,12 +4291,13 @@ public struct CodeBlockItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterSemicolon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.codeBlockItem, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.codeBlockItem, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4344,8 +4368,8 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .codeBlock else { - return nil + guard node.raw.kind == .codeBlock else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4359,14 +4383,14 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4380,7 +4404,7 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenStatementsAndRightBrace, rightBrace, unexpectedAfterRightBrace - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftBrace?.raw, leftBrace.raw, @@ -4391,12 +4415,13 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.codeBlock, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.codeBlock, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4450,8 +4475,8 @@ public struct CodeBlockSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return CodeBlockSyntax(newData) @@ -4504,8 +4529,8 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .compositionTypeElement else { - return nil + guard node.raw.kind == .compositionTypeElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4519,12 +4544,12 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndAmpersand: UnexpectedNodesSyntax? = nil, - ampersand: TokenSyntax? = nil, - _ unexpectedAfterAmpersand: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndAmpersand: UnexpectedNodesSyntax? = nil, + ampersand: TokenSyntax? = nil, + _ unexpectedAfterAmpersand: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4536,7 +4561,7 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenTypeAndAmpersand, ampersand, unexpectedAfterAmpersand - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeType?.raw, type.raw, @@ -4545,12 +4570,13 @@ public struct CompositionTypeElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterAmpersand?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.compositionTypeElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.compositionTypeElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4635,8 +4661,8 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: Node) { @@ -4658,19 +4684,19 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(ExprSyntax.self) { self = .expression(node) - return + return } if let node = node.as(AvailabilityConditionSyntax.self) { self = .availability(node) - return + return } if let node = node.as(MatchingPatternConditionSyntax.self) { self = .matchingPattern(node) - return + return } if let node = node.as(OptionalBindingConditionSyntax.self) { self = .optionalBinding(node) - return + return } return nil } @@ -4688,8 +4714,8 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conditionElement else { - return nil + guard node.raw.kind == .conditionElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4703,12 +4729,12 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, - condition: Condition, - _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeCondition: UnexpectedNodesSyntax? = nil, + condition: Condition, + _ unexpectedBetweenConditionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4720,7 +4746,7 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenConditionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeCondition?.raw, condition.raw, @@ -4729,12 +4755,13 @@ public struct ConditionElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conditionElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.conditionElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4803,8 +4830,8 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conformanceRequirement else { - return nil + guard node.raw.kind == .conformanceRequirement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4818,14 +4845,14 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? = nil, - leftTypeIdentifier: L, - _ unexpectedBetweenLeftTypeIdentifierAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndRightTypeIdentifier: UnexpectedNodesSyntax? = nil, - rightTypeIdentifier: R, - _ unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? = nil, + leftTypeIdentifier: L, + _ unexpectedBetweenLeftTypeIdentifierAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndRightTypeIdentifier: UnexpectedNodesSyntax? = nil, + rightTypeIdentifier: R, + _ unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4839,7 +4866,7 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenColonAndRightTypeIdentifier, rightTypeIdentifier, unexpectedAfterRightTypeIdentifier - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftTypeIdentifier?.raw, leftTypeIdentifier.raw, @@ -4850,12 +4877,13 @@ public struct ConformanceRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightTypeIdentifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conformanceRequirement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.conformanceRequirement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -4944,8 +4972,8 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionAttributeArguments else { - return nil + guard node.raw.kind == .conventionAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -4959,18 +4987,18 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, - conventionLabel: TokenSyntax, - _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, - cTypeLabel: TokenSyntax? = nil, - _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, - cTypeString: StringLiteralExprSyntax? = nil, - _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeConventionLabel: UnexpectedNodesSyntax? = nil, + conventionLabel: TokenSyntax, + _ unexpectedBetweenConventionLabelAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCTypeLabel: UnexpectedNodesSyntax? = nil, + cTypeLabel: TokenSyntax? = nil, + _ unexpectedBetweenCTypeLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndCTypeString: UnexpectedNodesSyntax? = nil, + cTypeString: StringLiteralExprSyntax? = nil, + _ unexpectedAfterCTypeString: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -4988,7 +5016,7 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenColonAndCTypeString, cTypeString, unexpectedAfterCTypeString - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeConventionLabel?.raw, conventionLabel.raw, @@ -5003,12 +5031,13 @@ public struct ConventionAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterCTypeString?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.conventionAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5138,8 +5167,8 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { - return nil + guard node.raw.kind == .conventionWitnessMethodAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5153,14 +5182,14 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, - witnessMethodLabel: TokenSyntax = .keyword(.witness_method), - _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, - protocolName: TokenSyntax, - _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWitnessMethodLabel: UnexpectedNodesSyntax? = nil, + witnessMethodLabel: TokenSyntax = .keyword(.witness_method), + _ unexpectedBetweenWitnessMethodLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndProtocolName: UnexpectedNodesSyntax? = nil, + protocolName: TokenSyntax, + _ unexpectedAfterProtocolName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5174,7 +5203,7 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S unexpectedBetweenColonAndProtocolName, protocolName, unexpectedAfterProtocolName - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWitnessMethodLabel?.raw, witnessMethodLabel.raw, @@ -5185,12 +5214,13 @@ public struct ConventionWitnessMethodAttributeArgumentsSyntax: SyntaxProtocol, S unexpectedAfterProtocolName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.conventionWitnessMethodAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.conventionWitnessMethodAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5279,8 +5309,8 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifierDetail else { - return nil + guard node.raw.kind == .declModifierDetail else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5294,14 +5324,14 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, - detail: TokenSyntax, - _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndDetail: UnexpectedNodesSyntax? = nil, + detail: TokenSyntax, + _ unexpectedBetweenDetailAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5315,7 +5345,7 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDetailAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -5326,12 +5356,13 @@ public struct DeclModifierDetailSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifierDetail, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.declModifierDetail, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5420,8 +5451,8 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declModifier else { - return nil + guard node.raw.kind == .declModifier else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5435,12 +5466,12 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, - detail: DeclModifierDetailSyntax? = nil, - _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndDetail: UnexpectedNodesSyntax? = nil, + detail: DeclModifierDetailSyntax? = nil, + _ unexpectedAfterDetail: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5452,7 +5483,7 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndDetail, detail, unexpectedAfterDetail - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -5461,12 +5492,13 @@ public struct DeclModifierSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterDetail?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declModifier, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.declModifier, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5535,8 +5567,8 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declNameArgument else { - return nil + guard node.raw.kind == .declNameArgument else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5550,12 +5582,12 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5567,7 +5599,7 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndColon, colon, unexpectedAfterColon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -5576,12 +5608,13 @@ public struct DeclNameArgumentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterColon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declNameArgument, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.declNameArgument, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5650,8 +5683,8 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declNameArguments else { - return nil + guard node.raw.kind == .declNameArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5665,14 +5698,14 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentListSyntax, + _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5686,7 +5719,7 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenArgumentsAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -5697,12 +5730,13 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declNameArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.declNameArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5756,8 +5790,8 @@ public struct DeclNameArgumentsSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.declNameArgumentList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return DeclNameArgumentsSyntax(newData) @@ -5810,8 +5844,8 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .declName else { - return nil + guard node.raw.kind == .declName else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5825,12 +5859,12 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? = nil, - declBaseName: TokenSyntax, - _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDeclBaseName: UnexpectedNodesSyntax? = nil, + declBaseName: TokenSyntax, + _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5842,7 +5876,7 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeDeclBaseName?.raw, declBaseName.raw, @@ -5851,12 +5885,13 @@ public struct DeclNameSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterDeclNameArguments?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.declName, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.declName, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -5927,8 +5962,8 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .derivativeRegistrationAttributeArguments else { - return nil + guard node.raw.kind == .derivativeRegistrationAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -5942,22 +5977,22 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, - ofLabel: TokenSyntax = .keyword(.of), - _ unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? = nil, - originalDeclName: QualifiedDeclNameSyntax, - _ unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax? = nil, - _ unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? = nil, - accessorKind: TokenSyntax? = nil, - _ unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamsClauseSyntax? = nil, - _ unexpectedAfterDiffParams: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeOfLabel: UnexpectedNodesSyntax? = nil, + ofLabel: TokenSyntax = .keyword(.of), + _ unexpectedBetweenOfLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndOriginalDeclName: UnexpectedNodesSyntax? = nil, + originalDeclName: QualifiedDeclNameSyntax, + _ unexpectedBetweenOriginalDeclNameAndPeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax? = nil, + _ unexpectedBetweenPeriodAndAccessorKind: UnexpectedNodesSyntax? = nil, + accessorKind: TokenSyntax? = nil, + _ unexpectedBetweenAccessorKindAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamsClauseSyntax? = nil, + _ unexpectedAfterDiffParams: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -5979,7 +6014,7 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy unexpectedBetweenCommaAndDiffParams, diffParams, unexpectedAfterDiffParams - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeOfLabel?.raw, ofLabel.raw, @@ -5998,12 +6033,13 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy unexpectedAfterDiffParams?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.derivativeRegistrationAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.derivativeRegistrationAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6177,8 +6213,8 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .designatedTypeElement else { - return nil + guard node.raw.kind == .designatedTypeElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6192,12 +6228,12 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, - leadingComma: TokenSyntax = .commaToken(), - _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeadingComma: UnexpectedNodesSyntax? = nil, + leadingComma: TokenSyntax = .commaToken(), + _ unexpectedBetweenLeadingCommaAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedAfterName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6209,7 +6245,7 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenLeadingCommaAndName, name, unexpectedAfterName - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeadingComma?.raw, leadingComma.raw, @@ -6218,12 +6254,13 @@ public struct DesignatedTypeElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.designatedTypeElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.designatedTypeElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6292,8 +6329,8 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dictionaryElement else { - return nil + guard node.raw.kind == .dictionaryElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6307,16 +6344,16 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeKeyExpression: UnexpectedNodesSyntax? = nil, - keyExpression: K, - _ unexpectedBetweenKeyExpressionAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValueExpression: UnexpectedNodesSyntax? = nil, - valueExpression: V, - _ unexpectedBetweenValueExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeKeyExpression: UnexpectedNodesSyntax? = nil, + keyExpression: K, + _ unexpectedBetweenKeyExpressionAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValueExpression: UnexpectedNodesSyntax? = nil, + valueExpression: V, + _ unexpectedBetweenValueExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6332,7 +6369,7 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenValueExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeKeyExpression?.raw, keyExpression.raw, @@ -6345,12 +6382,13 @@ public struct DictionaryElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dictionaryElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.dictionaryElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6459,8 +6497,8 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParam else { - return nil + guard node.raw.kind == .differentiabilityParam else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6474,12 +6512,12 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, - parameter: TokenSyntax, - _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeParameter: UnexpectedNodesSyntax? = nil, + parameter: TokenSyntax, + _ unexpectedBetweenParameterAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6491,7 +6529,7 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenParameterAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeParameter?.raw, parameter.raw, @@ -6500,12 +6538,13 @@ public struct DifferentiabilityParamSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParam, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.differentiabilityParam, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6584,8 +6623,8 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: DifferentiabilityParamSyntax) { @@ -6599,11 +6638,11 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl public init?(_ node: S) { if let node = node.as(DifferentiabilityParamSyntax.self) { self = .parameter(node) - return + return } if let node = node.as(DifferentiabilityParamsSyntax.self) { self = .parameterList(node) - return + return } return nil } @@ -6616,8 +6655,8 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParamsClause else { - return nil + guard node.raw.kind == .differentiabilityParamsClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6631,14 +6670,14 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, - wrtLabel: TokenSyntax = .keyword(.wrt), - _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, - parameters: Parameters, - _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWrtLabel: UnexpectedNodesSyntax? = nil, + wrtLabel: TokenSyntax = .keyword(.wrt), + _ unexpectedBetweenWrtLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndParameters: UnexpectedNodesSyntax? = nil, + parameters: Parameters, + _ unexpectedAfterParameters: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6652,7 +6691,7 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl unexpectedBetweenColonAndParameters, parameters, unexpectedAfterParameters - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWrtLabel?.raw, wrtLabel.raw, @@ -6663,12 +6702,13 @@ public struct DifferentiabilityParamsClauseSyntax: SyntaxProtocol, SyntaxHashabl unexpectedAfterParameters?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParamsClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.differentiabilityParamsClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6759,8 +6799,8 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiabilityParams else { - return nil + guard node.raw.kind == .differentiabilityParams else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6774,14 +6814,14 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamListSyntax, - _ unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamListSyntax, + _ unexpectedBetweenDiffParamsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6795,7 +6835,7 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDiffParamsAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -6806,12 +6846,13 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiabilityParams, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.differentiabilityParams, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -6866,8 +6907,8 @@ public struct DifferentiabilityParamsSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.differentiabilityParamList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return DifferentiabilityParamsSyntax(newData) @@ -6920,8 +6961,8 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .differentiableAttributeArguments else { - return nil + guard node.raw.kind == .differentiableAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -6935,18 +6976,18 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDiffKind: UnexpectedNodesSyntax? = nil, - diffKind: TokenSyntax? = nil, - _ unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? = nil, - diffKindComma: TokenSyntax? = nil, - _ unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? = nil, - diffParams: DifferentiabilityParamsClauseSyntax? = nil, - _ unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? = nil, - diffParamsComma: TokenSyntax? = nil, - _ unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedAfterWhereClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDiffKind: UnexpectedNodesSyntax? = nil, + diffKind: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindAndDiffKindComma: UnexpectedNodesSyntax? = nil, + diffKindComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffKindCommaAndDiffParams: UnexpectedNodesSyntax? = nil, + diffParams: DifferentiabilityParamsClauseSyntax? = nil, + _ unexpectedBetweenDiffParamsAndDiffParamsComma: UnexpectedNodesSyntax? = nil, + diffParamsComma: TokenSyntax? = nil, + _ unexpectedBetweenDiffParamsCommaAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedAfterWhereClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -6964,7 +7005,7 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash unexpectedBetweenDiffParamsCommaAndWhereClause, whereClause, unexpectedAfterWhereClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeDiffKind?.raw, diffKind?.raw, @@ -6979,12 +7020,13 @@ public struct DifferentiableAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHash unexpectedAfterWhereClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.differentiableAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.differentiableAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -7125,8 +7167,8 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: TokenSyntax) { @@ -7140,11 +7182,11 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab public init?(_ node: S) { if let node = node.as(TokenSyntax.self) { self = .token(node) - return + return } if let node = node.as(StringLiteralExprSyntax.self) { self = .string(node) - return + return } return nil } @@ -7157,8 +7199,8 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .documentationAttributeArgument else { - return nil + guard node.raw.kind == .documentationAttributeArgument else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7172,16 +7214,16 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: Value, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: Value, + _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -7197,7 +7239,7 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, @@ -7210,12 +7252,13 @@ public struct DocumentationAttributeArgumentSyntax: SyntaxProtocol, SyntaxHashab unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.documentationAttributeArgument, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.documentationAttributeArgument, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -7325,8 +7368,8 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dynamicReplacementArguments else { - return nil + guard node.raw.kind == .dynamicReplacementArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7340,14 +7383,14 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, - forLabel: TokenSyntax = .keyword(.for), - _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeForLabel: UnexpectedNodesSyntax? = nil, + forLabel: TokenSyntax = .keyword(.for), + _ unexpectedBetweenForLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedAfterDeclname: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -7361,7 +7404,7 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenColonAndDeclname, declname, unexpectedAfterDeclname - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeForLabel?.raw, forLabel.raw, @@ -7372,12 +7415,13 @@ public struct DynamicReplacementArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterDeclname?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dynamicReplacementArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.dynamicReplacementArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -7466,8 +7510,8 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseElement else { - return nil + guard node.raw.kind == .enumCaseElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7481,16 +7525,16 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, - associatedValue: EnumCaseParameterClauseSyntax? = nil, - _ unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? = nil, - rawValue: InitializerClauseSyntax? = nil, - _ unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndAssociatedValue: UnexpectedNodesSyntax? = nil, + associatedValue: EnumCaseParameterClauseSyntax? = nil, + _ unexpectedBetweenAssociatedValueAndRawValue: UnexpectedNodesSyntax? = nil, + rawValue: InitializerClauseSyntax? = nil, + _ unexpectedBetweenRawValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -7506,7 +7550,7 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenRawValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeIdentifier?.raw, identifier.raw, @@ -7519,12 +7563,13 @@ public struct EnumCaseElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.enumCaseElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -7637,8 +7682,8 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseParameterClause else { - return nil + guard node.raw.kind == .enumCaseParameterClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7652,14 +7697,14 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, - parameterList: EnumCaseParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, + parameterList: EnumCaseParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -7673,7 +7718,7 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenParameterListAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -7684,12 +7729,13 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseParameterClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.enumCaseParameterClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -7745,8 +7791,8 @@ public struct EnumCaseParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.enumCaseParameterList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return EnumCaseParameterClauseSyntax(newData) @@ -7800,8 +7846,8 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .enumCaseParameter else { - return nil + guard node.raw.kind == .enumCaseParameter else { + return nil } self._syntaxNode = node._syntaxNode } @@ -7815,22 +7861,22 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, - firstName: TokenSyntax? = nil, - _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, - secondName: TokenSyntax? = nil, - _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndDefaultArgument: UnexpectedNodesSyntax? = nil, - defaultArgument: InitializerClauseSyntax? = nil, - _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax? = nil, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndDefaultArgument: UnexpectedNodesSyntax? = nil, + defaultArgument: InitializerClauseSyntax? = nil, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -7852,7 +7898,7 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeModifiers?.raw, modifiers?.raw, @@ -7871,12 +7917,13 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.enumCaseParameter, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.enumCaseParameter, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -7912,8 +7959,8 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return EnumCaseParameterSyntax(newData) @@ -8068,8 +8115,8 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .exposeAttributeArguments else { - return nil + guard node.raw.kind == .exposeAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8083,14 +8130,14 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLanguage: UnexpectedNodesSyntax? = nil, - language: TokenSyntax, - _ unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? = nil, - cxxName: StringLiteralExprSyntax? = nil, - _ unexpectedAfterCxxName: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLanguage: UnexpectedNodesSyntax? = nil, + language: TokenSyntax, + _ unexpectedBetweenLanguageAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndCxxName: UnexpectedNodesSyntax? = nil, + cxxName: StringLiteralExprSyntax? = nil, + _ unexpectedAfterCxxName: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -8104,7 +8151,7 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenCommaAndCxxName, cxxName, unexpectedAfterCxxName - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLanguage?.raw, language.raw, @@ -8115,12 +8162,13 @@ public struct ExposeAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterCxxName?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.exposeAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.exposeAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -8209,8 +8257,8 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .expressionSegment else { - return nil + guard node.raw.kind == .expressionSegment else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8224,18 +8272,18 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, - backslash: TokenSyntax = .backslashToken(), - _ unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? = nil, - delimiter: TokenSyntax? = nil, - _ unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? = nil, - expressions: TupleExprElementListSyntax, - _ unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBackslash: UnexpectedNodesSyntax? = nil, + backslash: TokenSyntax = .backslashToken(), + _ unexpectedBetweenBackslashAndDelimiter: UnexpectedNodesSyntax? = nil, + delimiter: TokenSyntax? = nil, + _ unexpectedBetweenDelimiterAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndExpressions: UnexpectedNodesSyntax? = nil, + expressions: TupleExprElementListSyntax, + _ unexpectedBetweenExpressionsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -8253,7 +8301,7 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionsAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBackslash?.raw, backslash.raw, @@ -8268,12 +8316,13 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.expressionSegment, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.expressionSegment, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -8363,8 +8412,8 @@ public struct ExpressionSegmentSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[7] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 7, with: collection, arena: arena) return ExpressionSegmentSyntax(newData) @@ -8421,8 +8470,8 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionEffectSpecifiers else { - return nil + guard node.raw.kind == .functionEffectSpecifiers else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8436,12 +8485,12 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, - asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, + asyncSpecifier: TokenSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -8453,7 +8502,7 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, unexpectedAfterThrowsSpecifier - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, @@ -8462,12 +8511,13 @@ public struct FunctionEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterThrowsSpecifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionEffectSpecifiers, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.functionEffectSpecifiers, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -8536,8 +8586,8 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionParameter else { - return nil + guard node.raw.kind == .functionParameter else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8551,26 +8601,26 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, - modifiers: ModifierListSyntax? = nil, - _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, - firstName: TokenSyntax, - _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, - secondName: TokenSyntax? = nil, - _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, - ellipsis: TokenSyntax? = nil, - _ unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? = nil, - defaultArgument: InitializerClauseSyntax? = nil, - _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil, + modifiers: ModifierListSyntax? = nil, + _ unexpectedBetweenModifiersAndFirstName: UnexpectedNodesSyntax? = nil, + firstName: TokenSyntax, + _ unexpectedBetweenFirstNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndDefaultArgument: UnexpectedNodesSyntax? = nil, + defaultArgument: InitializerClauseSyntax? = nil, + _ unexpectedBetweenDefaultArgumentAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -8596,7 +8646,7 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDefaultArgumentAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -8619,12 +8669,13 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionParameter, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.functionParameter, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -8660,8 +8711,8 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return FunctionParameterSyntax(newData) @@ -8697,8 +8748,8 @@ public struct FunctionParameterSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.modifierList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return FunctionParameterSyntax(newData) @@ -8871,8 +8922,8 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionSignature else { - return nil + guard node.raw.kind == .functionSignature else { + return nil } self._syntaxNode = node._syntaxNode } @@ -8886,14 +8937,14 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeInput: UnexpectedNodesSyntax? = nil, - input: ParameterClauseSyntax, - _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: FunctionEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax? = nil, - _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeInput: UnexpectedNodesSyntax? = nil, + input: ParameterClauseSyntax, + _ unexpectedBetweenInputAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: FunctionEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax? = nil, + _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -8907,7 +8958,7 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenEffectSpecifiersAndOutput, output, unexpectedAfterOutput - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeInput?.raw, input.raw, @@ -8918,12 +8969,13 @@ public struct FunctionSignatureSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterOutput?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionSignature, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.functionSignature, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -9012,8 +9064,8 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .genericArgumentClause else { - return nil + guard node.raw.kind == .genericArgumentClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9027,14 +9079,14 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, - leftAngleBracket: TokenSyntax = .leftAngleToken(), - _ unexpectedBetweenLeftAngleBracketAndArguments: UnexpectedNodesSyntax? = nil, - arguments: GenericArgumentListSyntax, - _ unexpectedBetweenArgumentsAndRightAngleBracket: UnexpectedNodesSyntax? = nil, - rightAngleBracket: TokenSyntax = .rightAngleToken(), - _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, + leftAngleBracket: TokenSyntax = .leftAngleToken(), + _ unexpectedBetweenLeftAngleBracketAndArguments: UnexpectedNodesSyntax? = nil, + arguments: GenericArgumentListSyntax, + _ unexpectedBetweenArgumentsAndRightAngleBracket: UnexpectedNodesSyntax? = nil, + rightAngleBracket: TokenSyntax = .rightAngleToken(), + _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -9048,7 +9100,7 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenArgumentsAndRightAngleBracket, rightAngleBracket, unexpectedAfterRightAngleBracket - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftAngleBracket?.raw, leftAngleBracket.raw, @@ -9059,12 +9111,13 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightAngleBracket?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.genericArgumentClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.genericArgumentClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -9118,8 +9171,8 @@ public struct GenericArgumentClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.genericArgumentList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.genericArgumentList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return GenericArgumentClauseSyntax(newData) @@ -9172,8 +9225,8 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .genericArgument else { - return nil + guard node.raw.kind == .genericArgument else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9187,12 +9240,12 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeArgumentType: UnexpectedNodesSyntax? = nil, - argumentType: A, - _ unexpectedBetweenArgumentTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeArgumentType: UnexpectedNodesSyntax? = nil, + argumentType: A, + _ unexpectedBetweenArgumentTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -9204,7 +9257,7 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenArgumentTypeAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeArgumentType?.raw, argumentType.raw, @@ -9213,12 +9266,13 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.genericArgument, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.genericArgument, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -9287,8 +9341,8 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .genericParameterClause else { - return nil + guard node.raw.kind == .genericParameterClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9302,16 +9356,16 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, - leftAngleBracket: TokenSyntax = .leftAngleToken(), - _ unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? = nil, - genericParameterList: GenericParameterListSyntax, - _ unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? = nil, - genericWhereClause: GenericWhereClauseSyntax? = nil, - _ unexpectedBetweenGenericWhereClauseAndRightAngleBracket: UnexpectedNodesSyntax? = nil, - rightAngleBracket: TokenSyntax = .rightAngleToken(), - _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, + leftAngleBracket: TokenSyntax = .leftAngleToken(), + _ unexpectedBetweenLeftAngleBracketAndGenericParameterList: UnexpectedNodesSyntax? = nil, + genericParameterList: GenericParameterListSyntax, + _ unexpectedBetweenGenericParameterListAndGenericWhereClause: UnexpectedNodesSyntax? = nil, + genericWhereClause: GenericWhereClauseSyntax? = nil, + _ unexpectedBetweenGenericWhereClauseAndRightAngleBracket: UnexpectedNodesSyntax? = nil, + rightAngleBracket: TokenSyntax = .rightAngleToken(), + _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -9327,7 +9381,7 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericWhereClauseAndRightAngleBracket, rightAngleBracket, unexpectedAfterRightAngleBracket - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftAngleBracket?.raw, leftAngleBracket.raw, @@ -9340,12 +9394,13 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightAngleBracket?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.genericParameterClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.genericParameterClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -9399,8 +9454,8 @@ public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.genericParameterList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.genericParameterList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return GenericParameterClauseSyntax(newData) @@ -9473,8 +9528,8 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .genericParameter else { - return nil + guard node.raw.kind == .genericParameter else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9488,20 +9543,20 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndEach: UnexpectedNodesSyntax? = nil, - each: TokenSyntax? = nil, - _ unexpectedBetweenEachAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndInheritedType: UnexpectedNodesSyntax? = nil, - inheritedType: I? = nil, - _ unexpectedBetweenInheritedTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndEach: UnexpectedNodesSyntax? = nil, + each: TokenSyntax? = nil, + _ unexpectedBetweenEachAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndInheritedType: UnexpectedNodesSyntax? = nil, + inheritedType: I? = nil, + _ unexpectedBetweenInheritedTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -9521,7 +9576,7 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenInheritedTypeAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAttributes?.raw, attributes?.raw, @@ -9538,12 +9593,13 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.genericParameter, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.genericParameter, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -9560,37 +9616,37 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndEach: UnexpectedNodesSyntax? = nil, - each: TokenSyntax? = nil, - _ unexpectedBetweenEachAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndInheritedType: UnexpectedNodesSyntax? = nil, - inheritedType: MissingTypeSyntax? = nil, - _ unexpectedBetweenInheritedTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndEach: UnexpectedNodesSyntax? = nil, + each: TokenSyntax? = nil, + _ unexpectedBetweenEachAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndInheritedType: UnexpectedNodesSyntax? = nil, + inheritedType: MissingTypeSyntax? = nil, + _ unexpectedBetweenInheritedTypeAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeAttributes, - attributes: attributes, - unexpectedBetweenAttributesAndEach, - each: each, - unexpectedBetweenEachAndName, - name: name, - unexpectedBetweenNameAndColon, - colon: colon, - unexpectedBetweenColonAndInheritedType, - inheritedType: Optional.none, - unexpectedBetweenInheritedTypeAndTrailingComma, - trailingComma: trailingComma, + leadingTrivia: leadingTrivia, + unexpectedBeforeAttributes, + attributes: attributes, + unexpectedBetweenAttributesAndEach, + each: each, + unexpectedBetweenEachAndName, + name: name, + unexpectedBetweenNameAndColon, + colon: colon, + unexpectedBetweenColonAndInheritedType, + inheritedType: Optional.none, + unexpectedBetweenInheritedTypeAndTrailingComma, + trailingComma: trailingComma, unexpectedAfterTrailingComma, trailingTrivia: trailingTrivia ) @@ -9626,8 +9682,8 @@ public struct GenericParameterSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return GenericParameterSyntax(newData) @@ -9771,8 +9827,8 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: SameTypeRequirementSyntax) { @@ -9790,15 +9846,15 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(SameTypeRequirementSyntax.self) { self = .sameTypeRequirement(node) - return + return } if let node = node.as(ConformanceRequirementSyntax.self) { self = .conformanceRequirement(node) - return + return } if let node = node.as(LayoutRequirementSyntax.self) { self = .layoutRequirement(node) - return + return } return nil } @@ -9811,8 +9867,8 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .genericRequirement else { - return nil + guard node.raw.kind == .genericRequirement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9826,12 +9882,12 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBody: UnexpectedNodesSyntax? = nil, - body: Body, - _ unexpectedBetweenBodyAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBody: UnexpectedNodesSyntax? = nil, + body: Body, + _ unexpectedBetweenBodyAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -9843,7 +9899,7 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenBodyAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBody?.raw, body.raw, @@ -9852,12 +9908,13 @@ public struct GenericRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.genericRequirement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.genericRequirement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -9926,8 +9983,8 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .genericWhereClause else { - return nil + guard node.raw.kind == .genericWhereClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -9941,12 +9998,12 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, - whereKeyword: TokenSyntax = .keyword(.where), - _ unexpectedBetweenWhereKeywordAndRequirementList: UnexpectedNodesSyntax? = nil, - requirementList: GenericRequirementListSyntax, - _ unexpectedAfterRequirementList: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, + whereKeyword: TokenSyntax = .keyword(.where), + _ unexpectedBetweenWhereKeywordAndRequirementList: UnexpectedNodesSyntax? = nil, + requirementList: GenericRequirementListSyntax, + _ unexpectedAfterRequirementList: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -9958,7 +10015,7 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenWhereKeywordAndRequirementList, requirementList, unexpectedAfterRequirementList - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWhereKeyword?.raw, whereKeyword.raw, @@ -9967,12 +10024,13 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRequirementList?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.genericWhereClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.genericWhereClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10026,8 +10084,8 @@ public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.genericRequirementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.genericRequirementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return GenericWhereClauseSyntax(newData) @@ -10079,8 +10137,8 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: CodeBlockItemListSyntax) { @@ -10106,23 +10164,23 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(CodeBlockItemListSyntax.self) { self = .statements(node) - return + return } if let node = node.as(SwitchCaseListSyntax.self) { self = .switchCases(node) - return + return } if let node = node.as(MemberDeclListSyntax.self) { self = .decls(node) - return + return } if let node = node.as(ExprSyntax.self) { self = .postfixExpression(node) - return + return } if let node = node.as(AttributeListSyntax.self) { self = .attributes(node) - return + return } return nil } @@ -10141,8 +10199,8 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .ifConfigClause else { - return nil + guard node.raw.kind == .ifConfigClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10156,14 +10214,14 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, - poundKeyword: TokenSyntax, - _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, - condition: C? = nil, - _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, - elements: Elements? = nil, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, + poundKeyword: TokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, + condition: C? = nil, + _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, + elements: Elements? = nil, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -10177,7 +10235,7 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenConditionAndElements, elements, unexpectedAfterElements - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePoundKeyword?.raw, poundKeyword.raw, @@ -10188,12 +10246,13 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterElements?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.ifConfigClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.ifConfigClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10210,25 +10269,25 @@ public struct IfConfigClauseSyntax: SyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, - poundKeyword: TokenSyntax, - _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, - condition: MissingExprSyntax? = nil, - _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, - elements: Elements? = nil, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePoundKeyword: UnexpectedNodesSyntax? = nil, + poundKeyword: TokenSyntax, + _ unexpectedBetweenPoundKeywordAndCondition: UnexpectedNodesSyntax? = nil, + condition: MissingExprSyntax? = nil, + _ unexpectedBetweenConditionAndElements: UnexpectedNodesSyntax? = nil, + elements: Elements? = nil, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforePoundKeyword, - poundKeyword: poundKeyword, - unexpectedBetweenPoundKeywordAndCondition, - condition: Optional.none, - unexpectedBetweenConditionAndElements, - elements: elements, + leadingTrivia: leadingTrivia, + unexpectedBeforePoundKeyword, + poundKeyword: poundKeyword, + unexpectedBetweenPoundKeywordAndCondition, + condition: Optional.none, + unexpectedBetweenConditionAndElements, + elements: elements, unexpectedAfterElements, trailingTrivia: trailingTrivia ) @@ -10317,8 +10376,8 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .implementsAttributeArguments else { - return nil + guard node.raw.kind == .implementsAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10332,16 +10391,16 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? = nil, - declBaseName: TokenSyntax, - _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndDeclBaseName: UnexpectedNodesSyntax? = nil, + declBaseName: TokenSyntax, + _ unexpectedBetweenDeclBaseNameAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterDeclNameArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -10357,7 +10416,7 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenDeclBaseNameAndDeclNameArguments, declNameArguments, unexpectedAfterDeclNameArguments - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeType?.raw, type.raw, @@ -10370,12 +10429,13 @@ public struct ImplementsAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterDeclNameArguments?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.implementsAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.implementsAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10488,8 +10548,8 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .inheritedType else { - return nil + guard node.raw.kind == .inheritedType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10503,12 +10563,12 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeTypeName: UnexpectedNodesSyntax? = nil, - typeName: T, - _ unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeTypeName: UnexpectedNodesSyntax? = nil, + typeName: T, + _ unexpectedBetweenTypeNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -10520,7 +10580,7 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenTypeNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeTypeName?.raw, typeName.raw, @@ -10529,12 +10589,13 @@ public struct InheritedTypeSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.inheritedType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.inheritedType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10603,8 +10664,8 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .initializerClause else { - return nil + guard node.raw.kind == .initializerClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10618,12 +10679,12 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, - equal: TokenSyntax = .equalToken(), - _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, - value: V, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -10635,7 +10696,7 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenEqualAndValue, value, unexpectedAfterValue - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeEqual?.raw, equal.raw, @@ -10644,12 +10705,13 @@ public struct InitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterValue?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.initializerClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.initializerClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10731,8 +10793,8 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: KeyPathPropertyComponentSyntax) { @@ -10750,15 +10812,15 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(KeyPathPropertyComponentSyntax.self) { self = .property(node) - return + return } if let node = node.as(KeyPathSubscriptComponentSyntax.self) { self = .subscript(node) - return + return } if let node = node.as(KeyPathOptionalComponentSyntax.self) { self = .optional(node) - return + return } return nil } @@ -10771,8 +10833,8 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathComponent else { - return nil + guard node.raw.kind == .keyPathComponent else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10786,12 +10848,12 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax? = nil, - _ unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? = nil, - component: Component, - _ unexpectedAfterComponent: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax? = nil, + _ unexpectedBetweenPeriodAndComponent: UnexpectedNodesSyntax? = nil, + component: Component, + _ unexpectedAfterComponent: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -10803,7 +10865,7 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenPeriodAndComponent, component, unexpectedAfterComponent - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePeriod?.raw, period?.raw, @@ -10812,12 +10874,13 @@ public struct KeyPathComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterComponent?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathComponent, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.keyPathComponent, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10886,8 +10949,8 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathOptionalComponent else { - return nil + guard node.raw.kind == .keyPathOptionalComponent else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10901,24 +10964,25 @@ public struct KeyPathOptionalComponentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, - questionOrExclamationMark: TokenSyntax, - _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, + questionOrExclamationMark: TokenSyntax, + _ unexpectedAfterQuestionOrExclamationMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeQuestionOrExclamationMark, questionOrExclamationMark, unexpectedAfterQuestionOrExclamationMark))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeQuestionOrExclamationMark?.raw, questionOrExclamationMark.raw, unexpectedAfterQuestionOrExclamationMark?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathOptionalComponent, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.keyPathOptionalComponent, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -10963,8 +11027,8 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathPropertyComponent else { - return nil + guard node.raw.kind == .keyPathPropertyComponent else { + return nil } self._syntaxNode = node._syntaxNode } @@ -10978,14 +11042,14 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, - declNameArguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax? = nil, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedBetweenIdentifierAndDeclNameArguments: UnexpectedNodesSyntax? = nil, + declNameArguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax? = nil, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -10999,7 +11063,7 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDeclNameArgumentsAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeIdentifier?.raw, identifier.raw, @@ -11010,12 +11074,13 @@ public struct KeyPathPropertyComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterGenericArgumentClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathPropertyComponent, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.keyPathPropertyComponent, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -11104,8 +11169,8 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .keyPathSubscriptComponent else { - return nil + guard node.raw.kind == .keyPathSubscriptComponent else { + return nil } self._syntaxNode = node._syntaxNode } @@ -11119,14 +11184,14 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? = nil, - leftBracket: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, - argumentList: TupleExprElementListSyntax, - _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, - rightBracket: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightBracket: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftBracket: UnexpectedNodesSyntax? = nil, + leftBracket: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftBracketAndArgumentList: UnexpectedNodesSyntax? = nil, + argumentList: TupleExprElementListSyntax, + _ unexpectedBetweenArgumentListAndRightBracket: UnexpectedNodesSyntax? = nil, + rightBracket: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -11140,7 +11205,7 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenArgumentListAndRightBracket, rightBracket, unexpectedAfterRightBracket - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftBracket?.raw, leftBracket.raw, @@ -11151,12 +11216,13 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightBracket?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.keyPathSubscriptComponent, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.keyPathSubscriptComponent, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -11210,8 +11276,8 @@ public struct KeyPathSubscriptComponentSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleExprElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return KeyPathSubscriptComponentSyntax(newData) @@ -11264,8 +11330,8 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .labeledSpecializeEntry else { - return nil + guard node.raw.kind == .labeledSpecializeEntry else { + return nil } self._syntaxNode = node._syntaxNode } @@ -11279,16 +11345,16 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ unexpectedBetweenValueAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -11304,7 +11370,7 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenValueAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, @@ -11317,12 +11383,13 @@ public struct LabeledSpecializeEntrySyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.labeledSpecializeEntry, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.labeledSpecializeEntry, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -11435,8 +11502,8 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .layoutRequirement else { - return nil + guard node.raw.kind == .layoutRequirement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -11450,24 +11517,24 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeTypeIdentifier: UnexpectedNodesSyntax? = nil, - typeIdentifier: T, - _ unexpectedBetweenTypeIdentifierAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndLayoutConstraint: UnexpectedNodesSyntax? = nil, - layoutConstraint: TokenSyntax, - _ unexpectedBetweenLayoutConstraintAndLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax? = nil, - _ unexpectedBetweenLeftParenAndSize: UnexpectedNodesSyntax? = nil, - size: TokenSyntax? = nil, - _ unexpectedBetweenSizeAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedBetweenCommaAndAlignment: UnexpectedNodesSyntax? = nil, - alignment: TokenSyntax? = nil, - _ unexpectedBetweenAlignmentAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax? = nil, - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeTypeIdentifier: UnexpectedNodesSyntax? = nil, + typeIdentifier: T, + _ unexpectedBetweenTypeIdentifierAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndLayoutConstraint: UnexpectedNodesSyntax? = nil, + layoutConstraint: TokenSyntax, + _ unexpectedBetweenLayoutConstraintAndLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax? = nil, + _ unexpectedBetweenLeftParenAndSize: UnexpectedNodesSyntax? = nil, + size: TokenSyntax? = nil, + _ unexpectedBetweenSizeAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedBetweenCommaAndAlignment: UnexpectedNodesSyntax? = nil, + alignment: TokenSyntax? = nil, + _ unexpectedBetweenAlignmentAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax? = nil, + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -11491,7 +11558,7 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAlignmentAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeTypeIdentifier?.raw, typeIdentifier.raw, @@ -11512,12 +11579,13 @@ public struct LayoutRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.layoutRequirement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.layoutRequirement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -11706,8 +11774,8 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .matchingPatternCondition else { - return nil + guard node.raw.kind == .matchingPatternCondition else { + return nil } self._syntaxNode = node._syntaxNode } @@ -11721,16 +11789,16 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax, - _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax, + _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -11746,7 +11814,7 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeCaseKeyword?.raw, caseKeyword.raw, @@ -11759,12 +11827,13 @@ public struct MatchingPatternConditionSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterInitializer?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.matchingPatternCondition, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.matchingPatternCondition, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -11873,8 +11942,8 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberDeclBlock else { - return nil + guard node.raw.kind == .memberDeclBlock else { + return nil } self._syntaxNode = node._syntaxNode } @@ -11888,14 +11957,14 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, - leftBrace: TokenSyntax = .leftBraceToken(), - _ unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? = nil, - members: MemberDeclListSyntax, - _ unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? = nil, - rightBrace: TokenSyntax = .rightBraceToken(), - _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftBrace: UnexpectedNodesSyntax? = nil, + leftBrace: TokenSyntax = .leftBraceToken(), + _ unexpectedBetweenLeftBraceAndMembers: UnexpectedNodesSyntax? = nil, + members: MemberDeclListSyntax, + _ unexpectedBetweenMembersAndRightBrace: UnexpectedNodesSyntax? = nil, + rightBrace: TokenSyntax = .rightBraceToken(), + _ unexpectedAfterRightBrace: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -11909,7 +11978,7 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenMembersAndRightBrace, rightBrace, unexpectedAfterRightBrace - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftBrace?.raw, leftBrace.raw, @@ -11920,12 +11989,13 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightBrace?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberDeclBlock, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.memberDeclBlock, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -11979,8 +12049,8 @@ public struct MemberDeclBlockSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.memberDeclList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.memberDeclList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return MemberDeclBlockSyntax(newData) @@ -12033,8 +12103,8 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberDeclListItem else { - return nil + guard node.raw.kind == .memberDeclListItem else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12048,12 +12118,12 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDecl: UnexpectedNodesSyntax? = nil, - decl: D, - _ unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? = nil, - semicolon: TokenSyntax? = nil, - _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDecl: UnexpectedNodesSyntax? = nil, + decl: D, + _ unexpectedBetweenDeclAndSemicolon: UnexpectedNodesSyntax? = nil, + semicolon: TokenSyntax? = nil, + _ unexpectedAfterSemicolon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12065,7 +12135,7 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDeclAndSemicolon, semicolon, unexpectedAfterSemicolon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeDecl?.raw, decl.raw, @@ -12074,12 +12144,13 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterSemicolon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberDeclListItem, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.memberDeclListItem, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -12145,13 +12216,13 @@ public struct MemberDeclListItemSyntax: SyntaxProtocol, SyntaxHashable { // MARK: - MissingSyntax - +/// In case the source code is missing a syntax node, this node stands in place of the missing node. public struct MissingSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .missing else { - return nil + guard node.raw.kind == .missing else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12165,27 +12236,31 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpected: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedAfterPlaceholder: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) {(arena, _) in - let layout: [RawSyntax?] = [unexpected?.raw] + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) {(arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.missing, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.missing, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpected: UnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -12194,8 +12269,27 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable { } } + /// A placeholder, i.e. `<#syntax#>` that can be inserted into the source code to represent the missing pattern./// This token should always have `presence = .missing` + public var placeholder: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = MissingSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterPlaceholder: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MissingSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { - return .layout([\Self.unexpected]) + return .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } } @@ -12206,8 +12300,8 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .multipleTrailingClosureElement else { - return nil + guard node.raw.kind == .multipleTrailingClosureElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12221,14 +12315,14 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? = nil, - closure: ClosureExprSyntax, - _ unexpectedAfterClosure: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndClosure: UnexpectedNodesSyntax? = nil, + closure: ClosureExprSyntax, + _ unexpectedAfterClosure: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12242,7 +12336,7 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab unexpectedBetweenColonAndClosure, closure, unexpectedAfterClosure - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, @@ -12253,12 +12347,13 @@ public struct MultipleTrailingClosureElementSyntax: SyntaxProtocol, SyntaxHashab unexpectedAfterClosure?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.multipleTrailingClosureElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.multipleTrailingClosureElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -12347,8 +12442,8 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .objCSelectorPiece else { - return nil + guard node.raw.kind == .objCSelectorPiece else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12362,12 +12457,12 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax? = nil, - _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12379,7 +12474,7 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndColon, colon, unexpectedAfterColon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name?.raw, @@ -12388,12 +12483,13 @@ public struct ObjCSelectorPieceSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterColon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.objCSelectorPiece, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.objCSelectorPiece, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -12462,8 +12558,8 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { - return nil + guard node.raw.kind == .opaqueReturnTypeOfAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12477,14 +12573,14 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, - mangledName: StringLiteralExprSyntax, - _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, - ordinal: TokenSyntax, - _ unexpectedAfterOrdinal: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeMangledName: UnexpectedNodesSyntax? = nil, + mangledName: StringLiteralExprSyntax, + _ unexpectedBetweenMangledNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndOrdinal: UnexpectedNodesSyntax? = nil, + ordinal: TokenSyntax, + _ unexpectedAfterOrdinal: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12498,7 +12594,7 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax unexpectedBetweenCommaAndOrdinal, ordinal, unexpectedAfterOrdinal - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeMangledName?.raw, mangledName.raw, @@ -12509,12 +12605,13 @@ public struct OpaqueReturnTypeOfAttributeArgumentsSyntax: SyntaxProtocol, Syntax unexpectedAfterOrdinal?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.opaqueReturnTypeOfAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -12605,8 +12702,8 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .operatorPrecedenceAndTypes else { - return nil + guard node.raw.kind == .operatorPrecedenceAndTypes else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12620,14 +12717,14 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, - precedenceGroup: TokenSyntax, - _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, - designatedTypes: DesignatedTypeListSyntax, - _ unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, + precedenceGroup: TokenSyntax, + _ unexpectedBetweenPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, + designatedTypes: DesignatedTypeListSyntax, + _ unexpectedAfterDesignatedTypes: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12641,7 +12738,7 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenPrecedenceGroupAndDesignatedTypes, designatedTypes, unexpectedAfterDesignatedTypes - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeColon?.raw, colon.raw, @@ -12652,12 +12749,13 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterDesignatedTypes?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.operatorPrecedenceAndTypes, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.operatorPrecedenceAndTypes, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -12731,8 +12829,8 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.designatedTypeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return OperatorPrecedenceAndTypesSyntax(newData) @@ -12767,8 +12865,8 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .optionalBindingCondition else { - return nil + guard node.raw.kind == .optionalBindingCondition else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12782,16 +12880,16 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBindingKeyword: UnexpectedNodesSyntax? = nil, - bindingKeyword: TokenSyntax, - _ unexpectedBetweenBindingKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax? = nil, - _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBindingKeyword: UnexpectedNodesSyntax? = nil, + bindingKeyword: TokenSyntax, + _ unexpectedBetweenBindingKeywordAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedAfterInitializer: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12807,7 +12905,7 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenTypeAnnotationAndInitializer, initializer, unexpectedAfterInitializer - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBindingKeyword?.raw, bindingKeyword.raw, @@ -12820,12 +12918,13 @@ public struct OptionalBindingConditionSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterInitializer?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.optionalBindingCondition, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.optionalBindingCondition, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -12934,8 +13033,8 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .originallyDefinedInArguments else { - return nil + guard node.raw.kind == .originallyDefinedInArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -12949,18 +13048,18 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? = nil, - moduleLabel: TokenSyntax = .keyword(.module), - _ unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? = nil, - moduleName: StringLiteralExprSyntax, - _ unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? = nil, - platforms: AvailabilityVersionRestrictionListSyntax, - _ unexpectedAfterPlatforms: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeModuleLabel: UnexpectedNodesSyntax? = nil, + moduleLabel: TokenSyntax = .keyword(.module), + _ unexpectedBetweenModuleLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndModuleName: UnexpectedNodesSyntax? = nil, + moduleName: StringLiteralExprSyntax, + _ unexpectedBetweenModuleNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndPlatforms: UnexpectedNodesSyntax? = nil, + platforms: AvailabilityVersionRestrictionListSyntax, + _ unexpectedAfterPlatforms: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -12978,7 +13077,7 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenCommaAndPlatforms, platforms, unexpectedAfterPlatforms - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeModuleLabel?.raw, moduleLabel.raw, @@ -12993,12 +13092,13 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterPlatforms?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.originallyDefinedInArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.originallyDefinedInArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -13106,8 +13206,8 @@ public struct OriginallyDefinedInArgumentsSyntax: SyntaxProtocol, SyntaxHashable if let col = raw.layoutView!.children[9] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.availabilityVersionRestrictionList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 9, with: collection, arena: arena) return OriginallyDefinedInArgumentsSyntax(newData) @@ -13146,8 +13246,8 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .parameterClause else { - return nil + guard node.raw.kind == .parameterClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -13161,14 +13261,14 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, - parameterList: FunctionParameterListSyntax, - _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndParameterList: UnexpectedNodesSyntax? = nil, + parameterList: FunctionParameterListSyntax, + _ unexpectedBetweenParameterListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -13182,7 +13282,7 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenParameterListAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -13193,12 +13293,13 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.parameterClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.parameterClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -13252,8 +13353,8 @@ public struct ParameterClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.functionParameterList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.functionParameterList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return ParameterClauseSyntax(newData) @@ -13316,8 +13417,8 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: AccessorBlockSyntax) { @@ -13331,11 +13432,11 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(AccessorBlockSyntax.self) { self = .accessors(node) - return + return } if let node = node.as(CodeBlockSyntax.self) { self = .getter(node) - return + return } return nil } @@ -13348,8 +13449,8 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .patternBinding else { - return nil + guard node.raw.kind == .patternBinding else { + return nil } self._syntaxNode = node._syntaxNode } @@ -13363,18 +13464,18 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax? = nil, - _ unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? = nil, - accessor: Accessor? = nil, - _ unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedBetweenInitializerAndAccessor: UnexpectedNodesSyntax? = nil, + accessor: Accessor? = nil, + _ unexpectedBetweenAccessorAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -13392,7 +13493,7 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAccessorAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforePattern?.raw, pattern.raw, @@ -13407,12 +13508,13 @@ public struct PatternBindingSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.patternBinding, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.patternBinding, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -13541,8 +13643,8 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .poundSourceLocationArgs else { - return nil + guard node.raw.kind == .poundSourceLocationArgs else { + return nil } self._syntaxNode = node._syntaxNode } @@ -13556,22 +13658,22 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? = nil, - fileArgLabel: TokenSyntax = .keyword(.file), - _ unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? = nil, - fileArgColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? = nil, - fileName: StringLiteralExprSyntax, - _ unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax = .commaToken(), - _ unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? = nil, - lineArgLabel: TokenSyntax = .keyword(.line), - _ unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? = nil, - lineArgColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? = nil, - lineNumber: TokenSyntax, - _ unexpectedAfterLineNumber: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeFileArgLabel: UnexpectedNodesSyntax? = nil, + fileArgLabel: TokenSyntax = .keyword(.file), + _ unexpectedBetweenFileArgLabelAndFileArgColon: UnexpectedNodesSyntax? = nil, + fileArgColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenFileArgColonAndFileName: UnexpectedNodesSyntax? = nil, + fileName: StringLiteralExprSyntax, + _ unexpectedBetweenFileNameAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax = .commaToken(), + _ unexpectedBetweenCommaAndLineArgLabel: UnexpectedNodesSyntax? = nil, + lineArgLabel: TokenSyntax = .keyword(.line), + _ unexpectedBetweenLineArgLabelAndLineArgColon: UnexpectedNodesSyntax? = nil, + lineArgColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenLineArgColonAndLineNumber: UnexpectedNodesSyntax? = nil, + lineNumber: TokenSyntax, + _ unexpectedAfterLineNumber: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -13593,7 +13695,7 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenLineArgColonAndLineNumber, lineNumber, unexpectedAfterLineNumber - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeFileArgLabel?.raw, fileArgLabel.raw, @@ -13612,12 +13714,13 @@ public struct PoundSourceLocationArgsSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterLineNumber?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.poundSourceLocationArgs, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.poundSourceLocationArgs, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -13786,8 +13889,8 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssignment else { - return nil + guard node.raw.kind == .precedenceGroupAssignment else { + return nil } self._syntaxNode = node._syntaxNode } @@ -13801,14 +13904,14 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, - assignmentKeyword: TokenSyntax = .keyword(.assignment), - _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, - flag: TokenSyntax, - _ unexpectedAfterFlag: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAssignmentKeyword: UnexpectedNodesSyntax? = nil, + assignmentKeyword: TokenSyntax = .keyword(.assignment), + _ unexpectedBetweenAssignmentKeywordAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndFlag: UnexpectedNodesSyntax? = nil, + flag: TokenSyntax, + _ unexpectedAfterFlag: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -13822,7 +13925,7 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenColonAndFlag, flag, unexpectedAfterFlag - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAssignmentKeyword?.raw, assignmentKeyword.raw, @@ -13833,12 +13936,13 @@ public struct PrecedenceGroupAssignmentSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterFlag?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssignment, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.precedenceGroupAssignment, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -13928,8 +14032,8 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupAssociativity else { - return nil + guard node.raw.kind == .precedenceGroupAssociativity else { + return nil } self._syntaxNode = node._syntaxNode } @@ -13943,14 +14047,14 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, - associativityKeyword: TokenSyntax = .keyword(.associativity), - _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, - value: TokenSyntax, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAssociativityKeyword: UnexpectedNodesSyntax? = nil, + associativityKeyword: TokenSyntax = .keyword(.associativity), + _ unexpectedBetweenAssociativityKeywordAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValue: UnexpectedNodesSyntax? = nil, + value: TokenSyntax, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -13964,7 +14068,7 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenColonAndValue, value, unexpectedAfterValue - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAssociativityKeyword?.raw, associativityKeyword.raw, @@ -13975,12 +14079,13 @@ public struct PrecedenceGroupAssociativitySyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterValue?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupAssociativity, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.precedenceGroupAssociativity, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14070,8 +14175,8 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupNameElement else { - return nil + guard node.raw.kind == .precedenceGroupNameElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14085,12 +14190,12 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14102,7 +14207,7 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -14111,12 +14216,13 @@ public struct PrecedenceGroupNameElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupNameElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.precedenceGroupNameElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14185,8 +14291,8 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .precedenceGroupRelation else { - return nil + guard node.raw.kind == .precedenceGroupRelation else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14200,14 +14306,14 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? = nil, - higherThanOrLowerThan: TokenSyntax, - _ unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? = nil, - otherNames: PrecedenceGroupNameListSyntax, - _ unexpectedAfterOtherNames: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeHigherThanOrLowerThan: UnexpectedNodesSyntax? = nil, + higherThanOrLowerThan: TokenSyntax, + _ unexpectedBetweenHigherThanOrLowerThanAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndOtherNames: UnexpectedNodesSyntax? = nil, + otherNames: PrecedenceGroupNameListSyntax, + _ unexpectedAfterOtherNames: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14221,7 +14327,7 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenColonAndOtherNames, otherNames, unexpectedAfterOtherNames - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeHigherThanOrLowerThan?.raw, higherThanOrLowerThan.raw, @@ -14232,12 +14338,13 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterOtherNames?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.precedenceGroupRelation, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.precedenceGroupRelation, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14311,8 +14418,8 @@ public struct PrecedenceGroupRelationSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.precedenceGroupNameList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return PrecedenceGroupRelationSyntax(newData) @@ -14347,8 +14454,8 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .primaryAssociatedTypeClause else { - return nil + guard node.raw.kind == .primaryAssociatedTypeClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14362,14 +14469,14 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, - leftAngleBracket: TokenSyntax = .leftAngleToken(), - _ unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? = nil, - primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax, - _ unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? = nil, - rightAngleBracket: TokenSyntax = .rightAngleToken(), - _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil, + leftAngleBracket: TokenSyntax = .leftAngleToken(), + _ unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? = nil, + primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax, + _ unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? = nil, + rightAngleBracket: TokenSyntax = .rightAngleToken(), + _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14383,7 +14490,7 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket, rightAngleBracket, unexpectedAfterRightAngleBracket - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftAngleBracket?.raw, leftAngleBracket.raw, @@ -14394,12 +14501,13 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable unexpectedAfterRightAngleBracket?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.primaryAssociatedTypeClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.primaryAssociatedTypeClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14453,8 +14561,8 @@ public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.primaryAssociatedTypeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.primaryAssociatedTypeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return PrimaryAssociatedTypeClauseSyntax(newData) @@ -14507,8 +14615,8 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .primaryAssociatedType else { - return nil + guard node.raw.kind == .primaryAssociatedType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14522,12 +14630,12 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14539,7 +14647,7 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -14548,12 +14656,13 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.primaryAssociatedType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.primaryAssociatedType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14622,8 +14731,8 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .qualifiedDeclName else { - return nil + guard node.raw.kind == .qualifiedDeclName else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14637,16 +14746,16 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: B? = nil, - _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax? = nil, - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: B? = nil, + _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax? = nil, + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14662,7 +14771,7 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndArguments, arguments, unexpectedAfterArguments - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBaseType?.raw, baseType?.raw, @@ -14675,12 +14784,13 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterArguments?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.qualifiedDeclName, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.qualifiedDeclName, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14697,29 +14807,29 @@ public struct QualifiedDeclNameSyntax: SyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: MissingTypeSyntax? = nil, - _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, - dot: TokenSyntax? = nil, - _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, - arguments: DeclNameArgumentsSyntax? = nil, - _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: MissingTypeSyntax? = nil, + _ unexpectedBetweenBaseTypeAndDot: UnexpectedNodesSyntax? = nil, + dot: TokenSyntax? = nil, + _ unexpectedBetweenDotAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndArguments: UnexpectedNodesSyntax? = nil, + arguments: DeclNameArgumentsSyntax? = nil, + _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeBaseType, - baseType: Optional.none, - unexpectedBetweenBaseTypeAndDot, - dot: dot, - unexpectedBetweenDotAndName, - name: name, - unexpectedBetweenNameAndArguments, - arguments: arguments, + leadingTrivia: leadingTrivia, + unexpectedBeforeBaseType, + baseType: Optional.none, + unexpectedBetweenBaseTypeAndDot, + dot: dot, + unexpectedBetweenDotAndName, + name: name, + unexpectedBetweenNameAndArguments, + arguments: arguments, unexpectedAfterArguments, trailingTrivia: trailingTrivia ) @@ -14831,8 +14941,8 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .returnClause else { - return nil + guard node.raw.kind == .returnClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14846,12 +14956,12 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeArrow: UnexpectedNodesSyntax? = nil, - arrow: TokenSyntax = .arrowToken(), - _ unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? = nil, - returnType: R, - _ unexpectedAfterReturnType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeArrow: UnexpectedNodesSyntax? = nil, + arrow: TokenSyntax = .arrowToken(), + _ unexpectedBetweenArrowAndReturnType: UnexpectedNodesSyntax? = nil, + returnType: R, + _ unexpectedAfterReturnType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14863,7 +14973,7 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenArrowAndReturnType, returnType, unexpectedAfterReturnType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeArrow?.raw, arrow.raw, @@ -14872,12 +14982,13 @@ public struct ReturnClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterReturnType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.returnClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.returnClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -14946,8 +15057,8 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .sameTypeRequirement else { - return nil + guard node.raw.kind == .sameTypeRequirement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -14961,14 +15072,14 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? = nil, - leftTypeIdentifier: L, - _ unexpectedBetweenLeftTypeIdentifierAndEqualityToken: UnexpectedNodesSyntax? = nil, - equalityToken: TokenSyntax, - _ unexpectedBetweenEqualityTokenAndRightTypeIdentifier: UnexpectedNodesSyntax? = nil, - rightTypeIdentifier: R, - _ unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftTypeIdentifier: UnexpectedNodesSyntax? = nil, + leftTypeIdentifier: L, + _ unexpectedBetweenLeftTypeIdentifierAndEqualityToken: UnexpectedNodesSyntax? = nil, + equalityToken: TokenSyntax, + _ unexpectedBetweenEqualityTokenAndRightTypeIdentifier: UnexpectedNodesSyntax? = nil, + rightTypeIdentifier: R, + _ unexpectedAfterRightTypeIdentifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -14982,7 +15093,7 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenEqualityTokenAndRightTypeIdentifier, rightTypeIdentifier, unexpectedAfterRightTypeIdentifier - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftTypeIdentifier?.raw, leftTypeIdentifier.raw, @@ -14993,12 +15104,13 @@ public struct SameTypeRequirementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightTypeIdentifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.sameTypeRequirement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.sameTypeRequirement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15087,8 +15199,8 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .sourceFile else { - return nil + guard node.raw.kind == .sourceFile else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15102,12 +15214,12 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, - eofToken: TokenSyntax = .eof(), - _ unexpectedAfterEOFToken: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedBetweenStatementsAndEOFToken: UnexpectedNodesSyntax? = nil, + eofToken: TokenSyntax = .eof(), + _ unexpectedAfterEOFToken: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -15119,7 +15231,7 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenStatementsAndEOFToken, eofToken, unexpectedAfterEOFToken - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeStatements?.raw, statements.raw, @@ -15128,12 +15240,13 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterEOFToken?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.sourceFile, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.sourceFile, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15169,8 +15282,8 @@ public struct SourceFileSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return SourceFileSyntax(newData) @@ -15221,8 +15334,8 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .stringSegment else { - return nil + guard node.raw.kind == .stringSegment else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15236,24 +15349,25 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeContent: UnexpectedNodesSyntax? = nil, - content: TokenSyntax, - _ unexpectedAfterContent: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeContent: UnexpectedNodesSyntax? = nil, + content: TokenSyntax, + _ unexpectedAfterContent: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeContent, content, unexpectedAfterContent))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeContent, content, unexpectedAfterContent))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeContent?.raw, content.raw, unexpectedAfterContent?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.stringSegment, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.stringSegment, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15298,8 +15412,8 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchCaseLabel else { - return nil + guard node.raw.kind == .switchCaseLabel else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15313,14 +15427,14 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax = .keyword(.case), - _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, - caseItems: CaseItemListSyntax, - _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax = .keyword(.case), + _ unexpectedBetweenCaseKeywordAndCaseItems: UnexpectedNodesSyntax? = nil, + caseItems: CaseItemListSyntax, + _ unexpectedBetweenCaseItemsAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -15334,7 +15448,7 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenCaseItemsAndColon, colon, unexpectedAfterColon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeCaseKeyword?.raw, caseKeyword.raw, @@ -15345,12 +15459,13 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterColon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCaseLabel, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.switchCaseLabel, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15404,8 +15519,8 @@ public struct SwitchCaseLabelSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.caseItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.caseItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return SwitchCaseLabelSyntax(newData) @@ -15468,8 +15583,8 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: SwitchDefaultLabelSyntax) { @@ -15483,11 +15598,11 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(SwitchDefaultLabelSyntax.self) { self = .default(node) - return + return } if let node = node.as(SwitchCaseLabelSyntax.self) { self = .case(node) - return + return } return nil } @@ -15500,8 +15615,8 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchCase else { - return nil + guard node.raw.kind == .switchCase else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15515,14 +15630,14 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, - unknownAttr: AttributeSyntax? = nil, - _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, - label: Label, - _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, - statements: CodeBlockItemListSyntax, - _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeUnknownAttr: UnexpectedNodesSyntax? = nil, + unknownAttr: AttributeSyntax? = nil, + _ unexpectedBetweenUnknownAttrAndLabel: UnexpectedNodesSyntax? = nil, + label: Label, + _ unexpectedBetweenLabelAndStatements: UnexpectedNodesSyntax? = nil, + statements: CodeBlockItemListSyntax, + _ unexpectedAfterStatements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -15536,7 +15651,7 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenLabelAndStatements, statements, unexpectedAfterStatements - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeUnknownAttr?.raw, unknownAttr?.raw, @@ -15547,12 +15662,13 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterStatements?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchCase, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.switchCase, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15624,8 +15740,8 @@ public struct SwitchCaseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.codeBlockItemList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return SwitchCaseSyntax(newData) @@ -15660,8 +15776,8 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .switchDefaultLabel else { - return nil + guard node.raw.kind == .switchDefaultLabel else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15675,12 +15791,12 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, - defaultKeyword: TokenSyntax = .keyword(.default), - _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDefaultKeyword: UnexpectedNodesSyntax? = nil, + defaultKeyword: TokenSyntax = .keyword(.default), + _ unexpectedBetweenDefaultKeywordAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedAfterColon: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -15692,7 +15808,7 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDefaultKeywordAndColon, colon, unexpectedAfterColon - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeDefaultKeyword?.raw, defaultKeyword.raw, @@ -15701,12 +15817,13 @@ public struct SwitchDefaultLabelSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterColon?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.switchDefaultLabel, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.switchDefaultLabel, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15775,8 +15892,8 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .targetFunctionEntry else { - return nil + guard node.raw.kind == .targetFunctionEntry else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15790,16 +15907,16 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax = .keyword(.target), - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, - declname: DeclNameSyntax, - _ unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax = .keyword(.target), + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndDeclname: UnexpectedNodesSyntax? = nil, + declname: DeclNameSyntax, + _ unexpectedBetweenDeclnameAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -15815,7 +15932,7 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenDeclnameAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label.raw, @@ -15828,12 +15945,13 @@ public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.targetFunctionEntry, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.targetFunctionEntry, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -15946,8 +16064,8 @@ public struct TupleExprElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tupleExprElement else { - return nil + guard node.raw.kind == .tupleExprElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -15961,16 +16079,16 @@ public struct TupleExprElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax? = nil, - _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax? = nil, + _ unexpectedBetweenLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -15986,7 +16104,7 @@ public struct TupleExprElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabel?.raw, label?.raw, @@ -15999,12 +16117,13 @@ public struct TupleExprElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tupleExprElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tupleExprElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -16113,8 +16232,8 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tuplePatternElement else { - return nil + guard node.raw.kind == .tuplePatternElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -16128,16 +16247,16 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabelName: UnexpectedNodesSyntax? = nil, - labelName: TokenSyntax? = nil, - _ unexpectedBetweenLabelNameAndLabelColon: UnexpectedNodesSyntax? = nil, - labelColon: TokenSyntax? = nil, - _ unexpectedBetweenLabelColonAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabelName: UnexpectedNodesSyntax? = nil, + labelName: TokenSyntax? = nil, + _ unexpectedBetweenLabelNameAndLabelColon: UnexpectedNodesSyntax? = nil, + labelColon: TokenSyntax? = nil, + _ unexpectedBetweenLabelColonAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -16153,7 +16272,7 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenPatternAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabelName?.raw, labelName?.raw, @@ -16166,12 +16285,13 @@ public struct TuplePatternElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tuplePatternElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tuplePatternElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -16280,8 +16400,8 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tupleTypeElement else { - return nil + guard node.raw.kind == .tupleTypeElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -16295,24 +16415,24 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeInOut: UnexpectedNodesSyntax? = nil, - inOut: TokenSyntax? = nil, - _ unexpectedBetweenInOutAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax? = nil, - _ unexpectedBetweenNameAndSecondName: UnexpectedNodesSyntax? = nil, - secondName: TokenSyntax? = nil, - _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax? = nil, - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, - ellipsis: TokenSyntax? = nil, - _ unexpectedBetweenEllipsisAndInitializer: UnexpectedNodesSyntax? = nil, - initializer: InitializerClauseSyntax? = nil, - _ unexpectedBetweenInitializerAndTrailingComma: UnexpectedNodesSyntax? = nil, - trailingComma: TokenSyntax? = nil, - _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeInOut: UnexpectedNodesSyntax? = nil, + inOut: TokenSyntax? = nil, + _ unexpectedBetweenInOutAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax? = nil, + _ unexpectedBetweenNameAndSecondName: UnexpectedNodesSyntax? = nil, + secondName: TokenSyntax? = nil, + _ unexpectedBetweenSecondNameAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax? = nil, + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedBetweenTypeAndEllipsis: UnexpectedNodesSyntax? = nil, + ellipsis: TokenSyntax? = nil, + _ unexpectedBetweenEllipsisAndInitializer: UnexpectedNodesSyntax? = nil, + initializer: InitializerClauseSyntax? = nil, + _ unexpectedBetweenInitializerAndTrailingComma: UnexpectedNodesSyntax? = nil, + trailingComma: TokenSyntax? = nil, + _ unexpectedAfterTrailingComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -16336,7 +16456,7 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenInitializerAndTrailingComma, trailingComma, unexpectedAfterTrailingComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeInOut?.raw, inOut?.raw, @@ -16357,12 +16477,13 @@ public struct TupleTypeElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterTrailingComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tupleTypeElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tupleTypeElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -16551,8 +16672,8 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeAnnotation else { - return nil + guard node.raw.kind == .typeAnnotation else { + return nil } self._syntaxNode = node._syntaxNode } @@ -16566,12 +16687,12 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedAfterType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedAfterType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -16583,7 +16704,7 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenColonAndType, type, unexpectedAfterType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeColon?.raw, colon.raw, @@ -16592,12 +16713,13 @@ public struct TypeAnnotationSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeAnnotation, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.typeAnnotation, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -16666,8 +16788,8 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeEffectSpecifiers else { - return nil + guard node.raw.kind == .typeEffectSpecifiers else { + return nil } self._syntaxNode = node._syntaxNode } @@ -16681,12 +16803,12 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, - asyncSpecifier: TokenSyntax? = nil, - _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, - throwsSpecifier: TokenSyntax? = nil, - _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeAsyncSpecifier: UnexpectedNodesSyntax? = nil, + asyncSpecifier: TokenSyntax? = nil, + _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: UnexpectedNodesSyntax? = nil, + throwsSpecifier: TokenSyntax? = nil, + _ unexpectedAfterThrowsSpecifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -16698,7 +16820,7 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenAsyncSpecifierAndThrowsSpecifier, throwsSpecifier, unexpectedAfterThrowsSpecifier - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeAsyncSpecifier?.raw, asyncSpecifier?.raw, @@ -16707,12 +16829,13 @@ public struct TypeEffectSpecifiersSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterThrowsSpecifier?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeEffectSpecifiers, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.typeEffectSpecifiers, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -16781,8 +16904,8 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeInheritanceClause else { - return nil + guard node.raw.kind == .typeInheritanceClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -16796,12 +16919,12 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? = nil, - inheritedTypeCollection: InheritedTypeListSyntax, - _ unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndInheritedTypeCollection: UnexpectedNodesSyntax? = nil, + inheritedTypeCollection: InheritedTypeListSyntax, + _ unexpectedAfterInheritedTypeCollection: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -16813,7 +16936,7 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenColonAndInheritedTypeCollection, inheritedTypeCollection, unexpectedAfterInheritedTypeCollection - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeColon?.raw, colon.raw, @@ -16822,12 +16945,13 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterInheritedTypeCollection?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInheritanceClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.typeInheritanceClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -16881,8 +17005,8 @@ public struct TypeInheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.inheritedTypeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.inheritedTypeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return TypeInheritanceClauseSyntax(newData) @@ -16915,8 +17039,8 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .typeInitializerClause else { - return nil + guard node.raw.kind == .typeInitializerClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -16930,12 +17054,12 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, - equal: TokenSyntax = .equalToken(), - _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, - value: V, - _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEqual: UnexpectedNodesSyntax? = nil, + equal: TokenSyntax = .equalToken(), + _ unexpectedBetweenEqualAndValue: UnexpectedNodesSyntax? = nil, + value: V, + _ unexpectedAfterValue: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -16947,7 +17071,7 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenEqualAndValue, value, unexpectedAfterValue - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeEqual?.raw, equal.raw, @@ -16956,12 +17080,13 @@ public struct TypeInitializerClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterValue?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.typeInitializerClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.typeInitializerClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17030,8 +17155,8 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .unavailableFromAsyncArguments else { - return nil + guard node.raw.kind == .unavailableFromAsyncArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -17045,14 +17170,14 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? = nil, - messageLabel: TokenSyntax = .keyword(.message), - _ unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? = nil, - message: StringLiteralExprSyntax, - _ unexpectedAfterMessage: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeMessageLabel: UnexpectedNodesSyntax? = nil, + messageLabel: TokenSyntax = .keyword(.message), + _ unexpectedBetweenMessageLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndMessage: UnexpectedNodesSyntax? = nil, + message: StringLiteralExprSyntax, + _ unexpectedAfterMessage: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -17066,7 +17191,7 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl unexpectedBetweenColonAndMessage, message, unexpectedAfterMessage - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeMessageLabel?.raw, messageLabel.raw, @@ -17077,12 +17202,13 @@ public struct UnavailableFromAsyncArgumentsSyntax: SyntaxProtocol, SyntaxHashabl unexpectedAfterMessage?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.unavailableFromAsyncArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.unavailableFromAsyncArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17171,8 +17297,8 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .underscorePrivateAttributeArguments else { - return nil + guard node.raw.kind == .underscorePrivateAttributeArguments else { + return nil } self._syntaxNode = node._syntaxNode } @@ -17186,14 +17312,14 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? = nil, - sourceFileLabel: TokenSyntax = .keyword(.sourceFile), - _ unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? = nil, - filename: StringLiteralExprSyntax, - _ unexpectedAfterFilename: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSourceFileLabel: UnexpectedNodesSyntax? = nil, + sourceFileLabel: TokenSyntax = .keyword(.sourceFile), + _ unexpectedBetweenSourceFileLabelAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndFilename: UnexpectedNodesSyntax? = nil, + filename: StringLiteralExprSyntax, + _ unexpectedAfterFilename: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -17207,7 +17333,7 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH unexpectedBetweenColonAndFilename, filename, unexpectedAfterFilename - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSourceFileLabel?.raw, sourceFileLabel.raw, @@ -17218,12 +17344,13 @@ public struct UnderscorePrivateAttributeArgumentsSyntax: SyntaxProtocol, SyntaxH unexpectedAfterFilename?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.underscorePrivateAttributeArguments, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.underscorePrivateAttributeArguments, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17312,8 +17439,8 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .versionTuple else { - return nil + guard node.raw.kind == .versionTuple else { + return nil } self._syntaxNode = node._syntaxNode } @@ -17327,18 +17454,18 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeMajor: UnexpectedNodesSyntax? = nil, - major: TokenSyntax, - _ unexpectedBetweenMajorAndMinorPeriod: UnexpectedNodesSyntax? = nil, - minorPeriod: TokenSyntax? = nil, - _ unexpectedBetweenMinorPeriodAndMinor: UnexpectedNodesSyntax? = nil, - minor: TokenSyntax? = nil, - _ unexpectedBetweenMinorAndPatchPeriod: UnexpectedNodesSyntax? = nil, - patchPeriod: TokenSyntax? = nil, - _ unexpectedBetweenPatchPeriodAndPatch: UnexpectedNodesSyntax? = nil, - patch: TokenSyntax? = nil, - _ unexpectedAfterPatch: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeMajor: UnexpectedNodesSyntax? = nil, + major: TokenSyntax, + _ unexpectedBetweenMajorAndMinorPeriod: UnexpectedNodesSyntax? = nil, + minorPeriod: TokenSyntax? = nil, + _ unexpectedBetweenMinorPeriodAndMinor: UnexpectedNodesSyntax? = nil, + minor: TokenSyntax? = nil, + _ unexpectedBetweenMinorAndPatchPeriod: UnexpectedNodesSyntax? = nil, + patchPeriod: TokenSyntax? = nil, + _ unexpectedBetweenPatchPeriodAndPatch: UnexpectedNodesSyntax? = nil, + patch: TokenSyntax? = nil, + _ unexpectedAfterPatch: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -17356,7 +17483,7 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenPatchPeriodAndPatch, patch, unexpectedAfterPatch - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeMajor?.raw, major.raw, @@ -17371,12 +17498,13 @@ public struct VersionTupleSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterPatch?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.versionTuple, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.versionTuple, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17510,8 +17638,8 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .whereClause else { - return nil + guard node.raw.kind == .whereClause else { + return nil } self._syntaxNode = node._syntaxNode } @@ -17525,12 +17653,12 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, - whereKeyword: TokenSyntax = .keyword(.where), - _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, - guardResult: G, - _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWhereKeyword: UnexpectedNodesSyntax? = nil, + whereKeyword: TokenSyntax = .keyword(.where), + _ unexpectedBetweenWhereKeywordAndGuardResult: UnexpectedNodesSyntax? = nil, + guardResult: G, + _ unexpectedAfterGuardResult: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -17542,7 +17670,7 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenWhereKeywordAndGuardResult, guardResult, unexpectedAfterGuardResult - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWhereKeyword?.raw, whereKeyword.raw, @@ -17551,12 +17679,13 @@ public struct WhereClauseSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterGuardResult?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.whereClause, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.whereClause, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17625,8 +17754,8 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .yieldExprListElement else { - return nil + guard node.raw.kind == .yieldExprListElement else { + return nil } self._syntaxNode = node._syntaxNode } @@ -17640,12 +17769,12 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? = nil, - comma: TokenSyntax? = nil, - _ unexpectedAfterComma: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedBetweenExpressionAndComma: UnexpectedNodesSyntax? = nil, + comma: TokenSyntax? = nil, + _ unexpectedAfterComma: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -17657,7 +17786,7 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenExpressionAndComma, comma, unexpectedAfterComma - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeExpression?.raw, expression.raw, @@ -17666,12 +17795,13 @@ public struct YieldExprListElementSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterComma?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldExprListElement, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.yieldExprListElement, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17740,8 +17870,8 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .yieldList else { - return nil + guard node.raw.kind == .yieldList else { + return nil } self._syntaxNode = node._syntaxNode } @@ -17755,14 +17885,14 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, - elementList: YieldExprListSyntax, - _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndElementList: UnexpectedNodesSyntax? = nil, + elementList: YieldExprListSyntax, + _ unexpectedBetweenElementListAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -17776,7 +17906,7 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { unexpectedBetweenElementListAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -17787,12 +17917,13 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldList, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.yieldList, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -17846,8 +17977,8 @@ public struct YieldListSyntax: SyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.yieldExprList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.yieldExprList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return YieldListSyntax(newData) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift index f4190687786..3c57a873352 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxPatternNodes.swift @@ -19,8 +19,8 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .expressionPattern else { - return nil + guard node.raw.kind == .expressionPattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -34,24 +34,25 @@ public struct ExpressionPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeExpression?.raw, expression.raw, unexpectedAfterExpression?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.expressionPattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.expressionPattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -96,8 +97,8 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .identifierPattern else { - return nil + guard node.raw.kind == .identifierPattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -111,24 +112,25 @@ public struct IdentifierPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, - identifier: TokenSyntax, - _ unexpectedAfterIdentifier: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, + identifier: TokenSyntax, + _ unexpectedAfterIdentifier: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeIdentifier, identifier, unexpectedAfterIdentifier))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeIdentifier?.raw, identifier.raw, unexpectedAfterIdentifier?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.identifierPattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.identifierPattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -173,8 +175,8 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .isTypePattern else { - return nil + guard node.raw.kind == .isTypePattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -188,12 +190,12 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeIsKeyword: UnexpectedNodesSyntax? = nil, - isKeyword: TokenSyntax = .keyword(.is), - _ unexpectedBetweenIsKeywordAndType: UnexpectedNodesSyntax? = nil, - type: T, - _ unexpectedAfterType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeIsKeyword: UnexpectedNodesSyntax? = nil, + isKeyword: TokenSyntax = .keyword(.is), + _ unexpectedBetweenIsKeywordAndType: UnexpectedNodesSyntax? = nil, + type: T, + _ unexpectedAfterType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -205,7 +207,7 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedBetweenIsKeywordAndType, type, unexpectedAfterType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeIsKeyword?.raw, isKeyword.raw, @@ -214,12 +216,13 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedAfterType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.isTypePattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.isTypePattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -283,13 +286,13 @@ public struct IsTypePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { // MARK: - MissingPatternSyntax - +/// In case the source code is missing a pattern, this node stands in place of the missing pattern. public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .missingPattern else { - return nil + guard node.raw.kind == .missingPattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -303,27 +306,31 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpected: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedAfterPlaceholder: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) {(arena, _) in - let layout: [RawSyntax?] = [unexpected?.raw] + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) {(arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.missingPattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.missingPattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpected: UnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -332,8 +339,27 @@ public struct MissingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } } + /// A placeholder, i.e. `<#pattern#>` that can be inserted into the source code to represent the missing pattern./// This token should always have `presence = .missing`. + public var placeholder: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = MissingPatternSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterPlaceholder: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MissingPatternSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { - return .layout([\Self.unexpected]) + return .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } } @@ -344,8 +370,8 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tuplePattern else { - return nil + guard node.raw.kind == .tuplePattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -359,14 +385,14 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndElements: UnexpectedNodesSyntax? = nil, - elements: TuplePatternElementListSyntax, - _ unexpectedBetweenElementsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndElements: UnexpectedNodesSyntax? = nil, + elements: TuplePatternElementListSyntax, + _ unexpectedBetweenElementsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -380,7 +406,7 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedBetweenElementsAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -391,12 +417,13 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tuplePattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tuplePattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -450,8 +477,8 @@ public struct TuplePatternSyntax: PatternSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tuplePatternElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tuplePatternElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return TuplePatternSyntax(newData) @@ -504,8 +531,8 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .valueBindingPattern else { - return nil + guard node.raw.kind == .valueBindingPattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -519,12 +546,12 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBindingKeyword: UnexpectedNodesSyntax? = nil, - bindingKeyword: TokenSyntax, - _ unexpectedBetweenBindingKeywordAndValuePattern: UnexpectedNodesSyntax? = nil, - valuePattern: V, - _ unexpectedAfterValuePattern: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBindingKeyword: UnexpectedNodesSyntax? = nil, + bindingKeyword: TokenSyntax, + _ unexpectedBetweenBindingKeywordAndValuePattern: UnexpectedNodesSyntax? = nil, + valuePattern: V, + _ unexpectedAfterValuePattern: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -536,7 +563,7 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedBetweenBindingKeywordAndValuePattern, valuePattern, unexpectedAfterValuePattern - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBindingKeyword?.raw, bindingKeyword.raw, @@ -545,12 +572,13 @@ public struct ValueBindingPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedAfterValuePattern?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.valueBindingPattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.valueBindingPattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -619,8 +647,8 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .wildcardPattern else { - return nil + guard node.raw.kind == .wildcardPattern else { + return nil } self._syntaxNode = node._syntaxNode } @@ -634,12 +662,12 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWildcard: UnexpectedNodesSyntax? = nil, - wildcard: TokenSyntax = .wildcardToken(), - _ unexpectedBetweenWildcardAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedAfterTypeAnnotation: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWildcard: UnexpectedNodesSyntax? = nil, + wildcard: TokenSyntax = .wildcardToken(), + _ unexpectedBetweenWildcardAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedAfterTypeAnnotation: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -651,7 +679,7 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedBetweenWildcardAndTypeAnnotation, typeAnnotation, unexpectedAfterTypeAnnotation - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWildcard?.raw, wildcard.raw, @@ -660,12 +688,13 @@ public struct WildcardPatternSyntax: PatternSyntaxProtocol, SyntaxHashable { unexpectedAfterTypeAnnotation?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.wildcardPattern, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.wildcardPattern, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift index 7df373ff1b4..1370f48b786 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxStmtNodes.swift @@ -19,8 +19,8 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .breakStmt else { - return nil + guard node.raw.kind == .breakStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -34,12 +34,12 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? = nil, - breakKeyword: TokenSyntax = .keyword(.break), - _ unexpectedBetweenBreakKeywordAndLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax? = nil, - _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBreakKeyword: UnexpectedNodesSyntax? = nil, + breakKeyword: TokenSyntax = .keyword(.break), + _ unexpectedBetweenBreakKeywordAndLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax? = nil, + _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -51,7 +51,7 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenBreakKeywordAndLabel, label, unexpectedAfterLabel - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBreakKeyword?.raw, breakKeyword.raw, @@ -60,12 +60,13 @@ public struct BreakStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterLabel?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.breakStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.breakStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -134,8 +135,8 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .continueStmt else { - return nil + guard node.raw.kind == .continueStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -149,12 +150,12 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeContinueKeyword: UnexpectedNodesSyntax? = nil, - continueKeyword: TokenSyntax = .keyword(.continue), - _ unexpectedBetweenContinueKeywordAndLabel: UnexpectedNodesSyntax? = nil, - label: TokenSyntax? = nil, - _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeContinueKeyword: UnexpectedNodesSyntax? = nil, + continueKeyword: TokenSyntax = .keyword(.continue), + _ unexpectedBetweenContinueKeywordAndLabel: UnexpectedNodesSyntax? = nil, + label: TokenSyntax? = nil, + _ unexpectedAfterLabel: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -166,7 +167,7 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenContinueKeywordAndLabel, label, unexpectedAfterLabel - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeContinueKeyword?.raw, continueKeyword.raw, @@ -175,12 +176,13 @@ public struct ContinueStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterLabel?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.continueStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.continueStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -249,8 +251,8 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .deferStmt else { - return nil + guard node.raw.kind == .deferStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -264,12 +266,12 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDeferKeyword: UnexpectedNodesSyntax? = nil, - deferKeyword: TokenSyntax = .keyword(.defer), - _ unexpectedBetweenDeferKeywordAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDeferKeyword: UnexpectedNodesSyntax? = nil, + deferKeyword: TokenSyntax = .keyword(.defer), + _ unexpectedBetweenDeferKeywordAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -281,7 +283,7 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenDeferKeywordAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeDeferKeyword?.raw, deferKeyword.raw, @@ -290,12 +292,13 @@ public struct DeferStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.deferStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.deferStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -364,8 +367,8 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .doStmt else { - return nil + guard node.raw.kind == .doStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -379,14 +382,14 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? = nil, - doKeyword: TokenSyntax = .keyword(.do), - _ unexpectedBetweenDoKeywordAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedBetweenBodyAndCatchClauses: UnexpectedNodesSyntax? = nil, - catchClauses: CatchClauseListSyntax? = nil, - _ unexpectedAfterCatchClauses: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeDoKeyword: UnexpectedNodesSyntax? = nil, + doKeyword: TokenSyntax = .keyword(.do), + _ unexpectedBetweenDoKeywordAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedBetweenBodyAndCatchClauses: UnexpectedNodesSyntax? = nil, + catchClauses: CatchClauseListSyntax? = nil, + _ unexpectedAfterCatchClauses: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -400,7 +403,7 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenBodyAndCatchClauses, catchClauses, unexpectedAfterCatchClauses - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeDoKeyword?.raw, doKeyword.raw, @@ -411,12 +414,13 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterCatchClauses?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.doStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.doStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -488,8 +492,8 @@ public struct DoStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[5] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.catchClauseList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 5, with: collection, arena: arena) return DoStmtSyntax(newData) @@ -524,8 +528,8 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .expressionStmt else { - return nil + guard node.raw.kind == .expressionStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -539,24 +543,25 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeExpression, expression, unexpectedAfterExpression))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeExpression?.raw, expression.raw, unexpectedAfterExpression?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.expressionStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.expressionStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -601,8 +606,8 @@ public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .fallthroughStmt else { - return nil + guard node.raw.kind == .fallthroughStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -616,24 +621,25 @@ public struct FallthroughStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? = nil, - fallthroughKeyword: TokenSyntax = .keyword(.fallthrough), - _ unexpectedAfterFallthroughKeyword: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeFallthroughKeyword: UnexpectedNodesSyntax? = nil, + fallthroughKeyword: TokenSyntax = .keyword(.fallthrough), + _ unexpectedAfterFallthroughKeyword: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFallthroughKeyword, fallthroughKeyword, unexpectedAfterFallthroughKeyword))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeFallthroughKeyword, fallthroughKeyword, unexpectedAfterFallthroughKeyword))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeFallthroughKeyword?.raw, fallthroughKeyword.raw, unexpectedAfterFallthroughKeyword?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.fallthroughStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.fallthroughStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -678,8 +684,8 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .forInStmt else { - return nil + guard node.raw.kind == .forInStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -693,28 +699,28 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeForKeyword: UnexpectedNodesSyntax? = nil, - forKeyword: TokenSyntax = .keyword(.for), - _ unexpectedBetweenForKeywordAndTryKeyword: UnexpectedNodesSyntax? = nil, - tryKeyword: TokenSyntax? = nil, - _ unexpectedBetweenTryKeywordAndAwaitKeyword: UnexpectedNodesSyntax? = nil, - awaitKeyword: TokenSyntax? = nil, - _ unexpectedBetweenAwaitKeywordAndCaseKeyword: UnexpectedNodesSyntax? = nil, - caseKeyword: TokenSyntax? = nil, - _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, - pattern: P, - _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, - typeAnnotation: TypeAnnotationSyntax? = nil, - _ unexpectedBetweenTypeAnnotationAndInKeyword: UnexpectedNodesSyntax? = nil, - inKeyword: TokenSyntax = .keyword(.in), - _ unexpectedBetweenInKeywordAndSequenceExpr: UnexpectedNodesSyntax? = nil, - sequenceExpr: S, - _ unexpectedBetweenSequenceExprAndWhereClause: UnexpectedNodesSyntax? = nil, - whereClause: WhereClauseSyntax? = nil, - _ unexpectedBetweenWhereClauseAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeForKeyword: UnexpectedNodesSyntax? = nil, + forKeyword: TokenSyntax = .keyword(.for), + _ unexpectedBetweenForKeywordAndTryKeyword: UnexpectedNodesSyntax? = nil, + tryKeyword: TokenSyntax? = nil, + _ unexpectedBetweenTryKeywordAndAwaitKeyword: UnexpectedNodesSyntax? = nil, + awaitKeyword: TokenSyntax? = nil, + _ unexpectedBetweenAwaitKeywordAndCaseKeyword: UnexpectedNodesSyntax? = nil, + caseKeyword: TokenSyntax? = nil, + _ unexpectedBetweenCaseKeywordAndPattern: UnexpectedNodesSyntax? = nil, + pattern: P, + _ unexpectedBetweenPatternAndTypeAnnotation: UnexpectedNodesSyntax? = nil, + typeAnnotation: TypeAnnotationSyntax? = nil, + _ unexpectedBetweenTypeAnnotationAndInKeyword: UnexpectedNodesSyntax? = nil, + inKeyword: TokenSyntax = .keyword(.in), + _ unexpectedBetweenInKeywordAndSequenceExpr: UnexpectedNodesSyntax? = nil, + sequenceExpr: S, + _ unexpectedBetweenSequenceExprAndWhereClause: UnexpectedNodesSyntax? = nil, + whereClause: WhereClauseSyntax? = nil, + _ unexpectedBetweenWhereClauseAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -742,7 +748,7 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenWhereClauseAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeForKeyword?.raw, forKeyword.raw, @@ -767,12 +773,13 @@ public struct ForInStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.forInStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.forInStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1001,8 +1008,8 @@ public struct ForgetStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .forgetStmt else { - return nil + guard node.raw.kind == .forgetStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1016,12 +1023,12 @@ public struct ForgetStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeForgetKeyword: UnexpectedNodesSyntax? = nil, - forgetKeyword: TokenSyntax = .keyword(._forget), - _ unexpectedBetweenForgetKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeForgetKeyword: UnexpectedNodesSyntax? = nil, + forgetKeyword: TokenSyntax = .keyword(._forget), + _ unexpectedBetweenForgetKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1033,7 +1040,7 @@ public struct ForgetStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenForgetKeywordAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeForgetKeyword?.raw, forgetKeyword.raw, @@ -1042,12 +1049,13 @@ public struct ForgetStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.forgetStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.forgetStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1116,8 +1124,8 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .guardStmt else { - return nil + guard node.raw.kind == .guardStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1131,16 +1139,16 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeGuardKeyword: UnexpectedNodesSyntax? = nil, - guardKeyword: TokenSyntax = .keyword(.guard), - _ unexpectedBetweenGuardKeywordAndConditions: UnexpectedNodesSyntax? = nil, - conditions: ConditionElementListSyntax, - _ unexpectedBetweenConditionsAndElseKeyword: UnexpectedNodesSyntax? = nil, - elseKeyword: TokenSyntax = .keyword(.else), - _ unexpectedBetweenElseKeywordAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeGuardKeyword: UnexpectedNodesSyntax? = nil, + guardKeyword: TokenSyntax = .keyword(.guard), + _ unexpectedBetweenGuardKeywordAndConditions: UnexpectedNodesSyntax? = nil, + conditions: ConditionElementListSyntax, + _ unexpectedBetweenConditionsAndElseKeyword: UnexpectedNodesSyntax? = nil, + elseKeyword: TokenSyntax = .keyword(.else), + _ unexpectedBetweenElseKeywordAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1156,7 +1164,7 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenElseKeywordAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeGuardKeyword?.raw, guardKeyword.raw, @@ -1169,12 +1177,13 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.guardStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.guardStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1228,8 +1237,8 @@ public struct GuardStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return GuardStmtSyntax(newData) @@ -1302,8 +1311,8 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .labeledStmt else { - return nil + guard node.raw.kind == .labeledStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1317,14 +1326,14 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLabelName: UnexpectedNodesSyntax? = nil, - labelName: TokenSyntax, - _ unexpectedBetweenLabelNameAndLabelColon: UnexpectedNodesSyntax? = nil, - labelColon: TokenSyntax = .colonToken(), - _ unexpectedBetweenLabelColonAndStatement: UnexpectedNodesSyntax? = nil, - statement: S, - _ unexpectedAfterStatement: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLabelName: UnexpectedNodesSyntax? = nil, + labelName: TokenSyntax, + _ unexpectedBetweenLabelNameAndLabelColon: UnexpectedNodesSyntax? = nil, + labelColon: TokenSyntax = .colonToken(), + _ unexpectedBetweenLabelColonAndStatement: UnexpectedNodesSyntax? = nil, + statement: S, + _ unexpectedAfterStatement: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1338,7 +1347,7 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenLabelColonAndStatement, statement, unexpectedAfterStatement - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLabelName?.raw, labelName.raw, @@ -1349,12 +1358,13 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterStatement?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.labeledStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.labeledStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1438,13 +1448,13 @@ public struct LabeledStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { // MARK: - MissingStmtSyntax - +/// In case the source code is missing a statement, this node stands in place of the missing statement. public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .missingStmt else { - return nil + guard node.raw.kind == .missingStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1458,27 +1468,31 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpected: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedAfterPlaceholder: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) {(arena, _) in - let layout: [RawSyntax?] = [unexpected?.raw] + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) {(arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.missingStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.missingStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpected: UnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -1487,8 +1501,27 @@ public struct MissingStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } } + /// A placeholder, i.e. `<#statement#>` that can be inserted into the source code to represent the missing pattern./// This token should always have `presence = .missing`. + public var placeholder: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = MissingStmtSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterPlaceholder: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MissingStmtSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { - return .layout([\Self.unexpected]) + return .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } } @@ -1499,8 +1532,8 @@ public struct RepeatWhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .repeatWhileStmt else { - return nil + guard node.raw.kind == .repeatWhileStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1514,16 +1547,16 @@ public struct RepeatWhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, - repeatKeyword: TokenSyntax = .keyword(.repeat), - _ unexpectedBetweenRepeatKeywordAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedBetweenBodyAndWhileKeyword: UnexpectedNodesSyntax? = nil, - whileKeyword: TokenSyntax = .keyword(.while), - _ unexpectedBetweenWhileKeywordAndCondition: UnexpectedNodesSyntax? = nil, - condition: C, - _ unexpectedAfterCondition: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, + repeatKeyword: TokenSyntax = .keyword(.repeat), + _ unexpectedBetweenRepeatKeywordAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedBetweenBodyAndWhileKeyword: UnexpectedNodesSyntax? = nil, + whileKeyword: TokenSyntax = .keyword(.while), + _ unexpectedBetweenWhileKeywordAndCondition: UnexpectedNodesSyntax? = nil, + condition: C, + _ unexpectedAfterCondition: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1539,7 +1572,7 @@ public struct RepeatWhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenWhileKeywordAndCondition, condition, unexpectedAfterCondition - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeRepeatKeyword?.raw, repeatKeyword.raw, @@ -1552,12 +1585,13 @@ public struct RepeatWhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterCondition?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.repeatWhileStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.repeatWhileStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1666,8 +1700,8 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .returnStmt else { - return nil + guard node.raw.kind == .returnStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1681,12 +1715,12 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, - returnKeyword: TokenSyntax = .keyword(.return), - _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E? = nil, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, + returnKeyword: TokenSyntax = .keyword(.return), + _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E? = nil, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1698,7 +1732,7 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenReturnKeywordAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeReturnKeyword?.raw, returnKeyword.raw, @@ -1707,12 +1741,13 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.returnStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.returnStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1729,21 +1764,21 @@ public struct ReturnStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { /// the base type would allow implicit conversion from a string literal, /// which the above initializer doesn't support. public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, - returnKeyword: TokenSyntax = .keyword(.return), - _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: MissingExprSyntax? = nil, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeReturnKeyword: UnexpectedNodesSyntax? = nil, + returnKeyword: TokenSyntax = .keyword(.return), + _ unexpectedBetweenReturnKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: MissingExprSyntax? = nil, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { self.init( - leadingTrivia: leadingTrivia, - unexpectedBeforeReturnKeyword, - returnKeyword: returnKeyword, - unexpectedBetweenReturnKeywordAndExpression, - expression: Optional.none, + leadingTrivia: leadingTrivia, + unexpectedBeforeReturnKeyword, + returnKeyword: returnKeyword, + unexpectedBetweenReturnKeywordAndExpression, + expression: Optional.none, unexpectedAfterExpression, trailingTrivia: trailingTrivia ) @@ -1812,8 +1847,8 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .throwStmt else { - return nil + guard node.raw.kind == .throwStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1827,12 +1862,12 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? = nil, - throwKeyword: TokenSyntax = .keyword(.throw), - _ unexpectedBetweenThrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, - expression: E, - _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeThrowKeyword: UnexpectedNodesSyntax? = nil, + throwKeyword: TokenSyntax = .keyword(.throw), + _ unexpectedBetweenThrowKeywordAndExpression: UnexpectedNodesSyntax? = nil, + expression: E, + _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1844,7 +1879,7 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenThrowKeywordAndExpression, expression, unexpectedAfterExpression - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeThrowKeyword?.raw, throwKeyword.raw, @@ -1853,12 +1888,13 @@ public struct ThrowStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterExpression?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.throwStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.throwStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1927,8 +1963,8 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .whileStmt else { - return nil + guard node.raw.kind == .whileStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1942,14 +1978,14 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWhileKeyword: UnexpectedNodesSyntax? = nil, - whileKeyword: TokenSyntax = .keyword(.while), - _ unexpectedBetweenWhileKeywordAndConditions: UnexpectedNodesSyntax? = nil, - conditions: ConditionElementListSyntax, - _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, - body: CodeBlockSyntax, - _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWhileKeyword: UnexpectedNodesSyntax? = nil, + whileKeyword: TokenSyntax = .keyword(.while), + _ unexpectedBetweenWhileKeywordAndConditions: UnexpectedNodesSyntax? = nil, + conditions: ConditionElementListSyntax, + _ unexpectedBetweenConditionsAndBody: UnexpectedNodesSyntax? = nil, + body: CodeBlockSyntax, + _ unexpectedAfterBody: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1963,7 +1999,7 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenConditionsAndBody, body, unexpectedAfterBody - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWhileKeyword?.raw, whileKeyword.raw, @@ -1974,12 +2010,13 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterBody?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.whileStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.whileStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2033,8 +2070,8 @@ public struct WhileStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.conditionElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return WhileStmtSyntax(newData) @@ -2097,8 +2134,8 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } } - init(_ data: SyntaxData) { - self.init(Syntax(data))! + init(_ data: SyntaxData) { + self.init(Syntax(data))! } public init(_ node: YieldListSyntax) { @@ -2112,11 +2149,11 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public init?(_ node: S) { if let node = node.as(YieldListSyntax.self) { self = .yieldList(node) - return + return } if let node = node.as(ExprSyntax.self) { self = .simpleYield(node) - return + return } return nil } @@ -2129,8 +2166,8 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .yieldStmt else { - return nil + guard node.raw.kind == .yieldStmt else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2144,12 +2181,12 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? = nil, - yieldKeyword: TokenSyntax = .keyword(.yield), - _ unexpectedBetweenYieldKeywordAndYields: UnexpectedNodesSyntax? = nil, - yields: Yields, - _ unexpectedAfterYields: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeYieldKeyword: UnexpectedNodesSyntax? = nil, + yieldKeyword: TokenSyntax = .keyword(.yield), + _ unexpectedBetweenYieldKeywordAndYields: UnexpectedNodesSyntax? = nil, + yields: Yields, + _ unexpectedAfterYields: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2161,7 +2198,7 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedBetweenYieldKeywordAndYields, yields, unexpectedAfterYields - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeYieldKeyword?.raw, yieldKeyword.raw, @@ -2170,12 +2207,13 @@ public struct YieldStmtSyntax: StmtSyntaxProtocol, SyntaxHashable { unexpectedAfterYields?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.yieldStmt, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.yieldStmt, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift index 33337afb667..b3c42bda968 100644 --- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift +++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxTypeNodes.swift @@ -19,8 +19,8 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .arrayType else { - return nil + guard node.raw.kind == .arrayType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -34,14 +34,14 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftSquareBracket: UnexpectedNodesSyntax? = nil, - leftSquareBracket: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftSquareBracketAndElementType: UnexpectedNodesSyntax? = nil, - elementType: E, - _ unexpectedBetweenElementTypeAndRightSquareBracket: UnexpectedNodesSyntax? = nil, - rightSquareBracket: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightSquareBracket: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftSquareBracket: UnexpectedNodesSyntax? = nil, + leftSquareBracket: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareBracketAndElementType: UnexpectedNodesSyntax? = nil, + elementType: E, + _ unexpectedBetweenElementTypeAndRightSquareBracket: UnexpectedNodesSyntax? = nil, + rightSquareBracket: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquareBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -55,7 +55,7 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenElementTypeAndRightSquareBracket, rightSquareBracket, unexpectedAfterRightSquareBracket - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftSquareBracket?.raw, leftSquareBracket.raw, @@ -66,12 +66,13 @@ public struct ArrayTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterRightSquareBracket?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.arrayType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.arrayType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -160,8 +161,8 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .attributedType else { - return nil + guard node.raw.kind == .attributedType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -175,14 +176,14 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, - specifier: TokenSyntax? = nil, - _ unexpectedBetweenSpecifierAndAttributes: UnexpectedNodesSyntax? = nil, - attributes: AttributeListSyntax? = nil, - _ unexpectedBetweenAttributesAndBaseType: UnexpectedNodesSyntax? = nil, - baseType: B, - _ unexpectedAfterBaseType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil, + specifier: TokenSyntax? = nil, + _ unexpectedBetweenSpecifierAndAttributes: UnexpectedNodesSyntax? = nil, + attributes: AttributeListSyntax? = nil, + _ unexpectedBetweenAttributesAndBaseType: UnexpectedNodesSyntax? = nil, + baseType: B, + _ unexpectedAfterBaseType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -196,7 +197,7 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenAttributesAndBaseType, baseType, unexpectedAfterBaseType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSpecifier?.raw, specifier?.raw, @@ -207,12 +208,13 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterBaseType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.attributedType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.attributedType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -266,8 +268,8 @@ public struct AttributedTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return AttributedTypeSyntax(newData) @@ -320,8 +322,8 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .classRestrictionType else { - return nil + guard node.raw.kind == .classRestrictionType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -335,24 +337,25 @@ public struct ClassRestrictionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeClassKeyword: UnexpectedNodesSyntax? = nil, - classKeyword: TokenSyntax = .keyword(.class), - _ unexpectedAfterClassKeyword: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeClassKeyword: UnexpectedNodesSyntax? = nil, + classKeyword: TokenSyntax = .keyword(.class), + _ unexpectedAfterClassKeyword: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeClassKeyword, classKeyword, unexpectedAfterClassKeyword))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeClassKeyword, classKeyword, unexpectedAfterClassKeyword))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeClassKeyword?.raw, classKeyword.raw, unexpectedAfterClassKeyword?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.classRestrictionType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.classRestrictionType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -397,8 +400,8 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .compositionType else { - return nil + guard node.raw.kind == .compositionType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -412,24 +415,25 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeElements: UnexpectedNodesSyntax? = nil, - elements: CompositionTypeElementListSyntax, - _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeElements: UnexpectedNodesSyntax? = nil, + elements: CompositionTypeElementListSyntax, + _ unexpectedAfterElements: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeElements, elements, unexpectedAfterElements))) {(arena, _) in + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeElements, elements, unexpectedAfterElements))) {(arena, _) in let layout: [RawSyntax?] = [unexpectedBeforeElements?.raw, elements.raw, unexpectedAfterElements?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.compositionType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.compositionType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -465,8 +469,8 @@ public struct CompositionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[1] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.compositionTypeElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.compositionTypeElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 1, with: collection, arena: arena) return CompositionTypeSyntax(newData) @@ -493,8 +497,8 @@ public struct ConstrainedSugarTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .constrainedSugarType else { - return nil + guard node.raw.kind == .constrainedSugarType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -508,12 +512,12 @@ public struct ConstrainedSugarTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeSomeOrAnySpecifier: UnexpectedNodesSyntax? = nil, - someOrAnySpecifier: TokenSyntax, - _ unexpectedBetweenSomeOrAnySpecifierAndBaseType: UnexpectedNodesSyntax? = nil, - baseType: B, - _ unexpectedAfterBaseType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeSomeOrAnySpecifier: UnexpectedNodesSyntax? = nil, + someOrAnySpecifier: TokenSyntax, + _ unexpectedBetweenSomeOrAnySpecifierAndBaseType: UnexpectedNodesSyntax? = nil, + baseType: B, + _ unexpectedAfterBaseType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -525,7 +529,7 @@ public struct ConstrainedSugarTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenSomeOrAnySpecifierAndBaseType, baseType, unexpectedAfterBaseType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeSomeOrAnySpecifier?.raw, someOrAnySpecifier.raw, @@ -534,12 +538,13 @@ public struct ConstrainedSugarTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterBaseType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.constrainedSugarType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.constrainedSugarType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -608,8 +613,8 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .dictionaryType else { - return nil + guard node.raw.kind == .dictionaryType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -623,18 +628,18 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftSquareBracket: UnexpectedNodesSyntax? = nil, - leftSquareBracket: TokenSyntax = .leftSquareBracketToken(), - _ unexpectedBetweenLeftSquareBracketAndKeyType: UnexpectedNodesSyntax? = nil, - keyType: K, - _ unexpectedBetweenKeyTypeAndColon: UnexpectedNodesSyntax? = nil, - colon: TokenSyntax = .colonToken(), - _ unexpectedBetweenColonAndValueType: UnexpectedNodesSyntax? = nil, - valueType: V, - _ unexpectedBetweenValueTypeAndRightSquareBracket: UnexpectedNodesSyntax? = nil, - rightSquareBracket: TokenSyntax = .rightSquareBracketToken(), - _ unexpectedAfterRightSquareBracket: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftSquareBracket: UnexpectedNodesSyntax? = nil, + leftSquareBracket: TokenSyntax = .leftSquareBracketToken(), + _ unexpectedBetweenLeftSquareBracketAndKeyType: UnexpectedNodesSyntax? = nil, + keyType: K, + _ unexpectedBetweenKeyTypeAndColon: UnexpectedNodesSyntax? = nil, + colon: TokenSyntax = .colonToken(), + _ unexpectedBetweenColonAndValueType: UnexpectedNodesSyntax? = nil, + valueType: V, + _ unexpectedBetweenValueTypeAndRightSquareBracket: UnexpectedNodesSyntax? = nil, + rightSquareBracket: TokenSyntax = .rightSquareBracketToken(), + _ unexpectedAfterRightSquareBracket: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -652,7 +657,7 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenValueTypeAndRightSquareBracket, rightSquareBracket, unexpectedAfterRightSquareBracket - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftSquareBracket?.raw, leftSquareBracket.raw, @@ -667,12 +672,13 @@ public struct DictionaryTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterRightSquareBracket?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.dictionaryType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.dictionaryType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -801,8 +807,8 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .functionType else { - return nil + guard node.raw.kind == .functionType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -816,18 +822,18 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, - arguments: TupleTypeElementListSyntax, - _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedBetweenRightParenAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, - effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, - _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, - output: ReturnClauseSyntax, - _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, + arguments: TupleTypeElementListSyntax, + _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedBetweenRightParenAndEffectSpecifiers: UnexpectedNodesSyntax? = nil, + effectSpecifiers: TypeEffectSpecifiersSyntax? = nil, + _ unexpectedBetweenEffectSpecifiersAndOutput: UnexpectedNodesSyntax? = nil, + output: ReturnClauseSyntax, + _ unexpectedAfterOutput: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -845,7 +851,7 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenEffectSpecifiersAndOutput, output, unexpectedAfterOutput - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -860,12 +866,13 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterOutput?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.functionType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.functionType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -919,8 +926,8 @@ public struct FunctionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return FunctionTypeSyntax(newData) @@ -1013,8 +1020,8 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .implicitlyUnwrappedOptionalType else { - return nil + guard node.raw.kind == .implicitlyUnwrappedOptionalType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1028,12 +1035,12 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWrappedType: UnexpectedNodesSyntax? = nil, - wrappedType: W, - _ unexpectedBetweenWrappedTypeAndExclamationMark: UnexpectedNodesSyntax? = nil, - exclamationMark: TokenSyntax = .exclamationMarkToken(), - _ unexpectedAfterExclamationMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWrappedType: UnexpectedNodesSyntax? = nil, + wrappedType: W, + _ unexpectedBetweenWrappedTypeAndExclamationMark: UnexpectedNodesSyntax? = nil, + exclamationMark: TokenSyntax = .exclamationMarkToken(), + _ unexpectedAfterExclamationMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1045,7 +1052,7 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH unexpectedBetweenWrappedTypeAndExclamationMark, exclamationMark, unexpectedAfterExclamationMark - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWrappedType?.raw, wrappedType.raw, @@ -1054,12 +1061,13 @@ public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntaxProtocol, SyntaxH unexpectedAfterExclamationMark?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.implicitlyUnwrappedOptionalType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.implicitlyUnwrappedOptionalType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1128,8 +1136,8 @@ public struct MemberTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .memberTypeIdentifier else { - return nil + guard node.raw.kind == .memberTypeIdentifier else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1143,16 +1151,16 @@ public struct MemberTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: B, - _ unexpectedBetweenBaseTypeAndPeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax = .periodToken(), - _ unexpectedBetweenPeriodAndName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax? = nil, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: B, + _ unexpectedBetweenBaseTypeAndPeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax = .periodToken(), + _ unexpectedBetweenPeriodAndName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax? = nil, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1168,7 +1176,7 @@ public struct MemberTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBaseType?.raw, baseType.raw, @@ -1181,12 +1189,13 @@ public struct MemberTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterGenericArgumentClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.memberTypeIdentifier, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.memberTypeIdentifier, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1295,8 +1304,8 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .metatypeType else { - return nil + guard node.raw.kind == .metatypeType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1310,14 +1319,14 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, - baseType: B, - _ unexpectedBetweenBaseTypeAndPeriod: UnexpectedNodesSyntax? = nil, - period: TokenSyntax = .periodToken(), - _ unexpectedBetweenPeriodAndTypeOrProtocol: UnexpectedNodesSyntax? = nil, - typeOrProtocol: TokenSyntax, - _ unexpectedAfterTypeOrProtocol: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeBaseType: UnexpectedNodesSyntax? = nil, + baseType: B, + _ unexpectedBetweenBaseTypeAndPeriod: UnexpectedNodesSyntax? = nil, + period: TokenSyntax = .periodToken(), + _ unexpectedBetweenPeriodAndTypeOrProtocol: UnexpectedNodesSyntax? = nil, + typeOrProtocol: TokenSyntax, + _ unexpectedAfterTypeOrProtocol: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1331,7 +1340,7 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenPeriodAndTypeOrProtocol, typeOrProtocol, unexpectedAfterTypeOrProtocol - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeBaseType?.raw, baseType.raw, @@ -1342,12 +1351,13 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterTypeOrProtocol?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.metatypeType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.metatypeType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1431,13 +1441,13 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { // MARK: - MissingTypeSyntax - +/// In case the source code is missing a type, this node stands in place of the missing type. public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .missingType else { - return nil + guard node.raw.kind == .missingType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1451,27 +1461,31 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpected: UnexpectedNodesSyntax? = nil, - trailingTrivia: Trivia? = nil + leadingTrivia: Trivia? = nil, + _ unexpectedBeforePlaceholder: UnexpectedNodesSyntax? = nil, + placeholder: TokenSyntax, + _ unexpectedAfterPlaceholder: UnexpectedNodesSyntax? = nil, + trailingTrivia: Trivia? = nil + ) { // Extend the lifetime of all parameters so their arenas don't get destroyed // before they can be added as children of the new arena. - let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) {(arena, _) in - let layout: [RawSyntax?] = [unexpected?.raw] + let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpectedBeforePlaceholder, placeholder, unexpectedAfterPlaceholder))) {(arena, _) in + let layout: [RawSyntax?] = [unexpectedBeforePlaceholder?.raw, placeholder.raw, unexpectedAfterPlaceholder?.raw] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.missingType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.missingType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) } - public var unexpected: UnexpectedNodesSyntax? { + public var unexpectedBeforePlaceholder: UnexpectedNodesSyntax? { get { return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) } @@ -1480,8 +1494,27 @@ public struct MissingTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } } + /// A placeholder, i.e. `<#type#>` that can be inserted into the source code to represent the missing type. This token should always have `presence = .missing`. + public var placeholder: TokenSyntax { + get { + return TokenSyntax(data.child(at: 1, parent: Syntax(self))!) + } + set(value) { + self = MissingTypeSyntax(data.replacingChild(at: 1, with: value.raw, arena: SyntaxArena())) + } + } + + public var unexpectedAfterPlaceholder: UnexpectedNodesSyntax? { + get { + return data.child(at: 2, parent: Syntax(self)).map(UnexpectedNodesSyntax.init) + } + set(value) { + self = MissingTypeSyntax(data.replacingChild(at: 2, with: value?.raw, arena: SyntaxArena())) + } + } + public static var structure: SyntaxNodeStructure { - return .layout([\Self.unexpected]) + return .layout([\Self.unexpectedBeforePlaceholder, \Self.placeholder, \Self.unexpectedAfterPlaceholder]) } } @@ -1492,8 +1525,8 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .namedOpaqueReturnType else { - return nil + guard node.raw.kind == .namedOpaqueReturnType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1507,12 +1540,12 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeGenericParameters: UnexpectedNodesSyntax? = nil, - genericParameters: GenericParameterClauseSyntax, - _ unexpectedBetweenGenericParametersAndBaseType: UnexpectedNodesSyntax? = nil, - baseType: B, - _ unexpectedAfterBaseType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeGenericParameters: UnexpectedNodesSyntax? = nil, + genericParameters: GenericParameterClauseSyntax, + _ unexpectedBetweenGenericParametersAndBaseType: UnexpectedNodesSyntax? = nil, + baseType: B, + _ unexpectedAfterBaseType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1524,7 +1557,7 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenGenericParametersAndBaseType, baseType, unexpectedAfterBaseType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeGenericParameters?.raw, genericParameters.raw, @@ -1533,12 +1566,13 @@ public struct NamedOpaqueReturnTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterBaseType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.namedOpaqueReturnType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.namedOpaqueReturnType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1607,8 +1641,8 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .optionalType else { - return nil + guard node.raw.kind == .optionalType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1622,12 +1656,12 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeWrappedType: UnexpectedNodesSyntax? = nil, - wrappedType: W, - _ unexpectedBetweenWrappedTypeAndQuestionMark: UnexpectedNodesSyntax? = nil, - questionMark: TokenSyntax = .postfixQuestionMarkToken(), - _ unexpectedAfterQuestionMark: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeWrappedType: UnexpectedNodesSyntax? = nil, + wrappedType: W, + _ unexpectedBetweenWrappedTypeAndQuestionMark: UnexpectedNodesSyntax? = nil, + questionMark: TokenSyntax = .postfixQuestionMarkToken(), + _ unexpectedAfterQuestionMark: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1639,7 +1673,7 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenWrappedTypeAndQuestionMark, questionMark, unexpectedAfterQuestionMark - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeWrappedType?.raw, wrappedType.raw, @@ -1648,12 +1682,13 @@ public struct OptionalTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterQuestionMark?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.optionalType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.optionalType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1722,8 +1757,8 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .packExpansionType else { - return nil + guard node.raw.kind == .packExpansionType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1737,12 +1772,12 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, - repeatKeyword: TokenSyntax = .keyword(.repeat), - _ unexpectedBetweenRepeatKeywordAndPatternType: UnexpectedNodesSyntax? = nil, - patternType: P, - _ unexpectedAfterPatternType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeRepeatKeyword: UnexpectedNodesSyntax? = nil, + repeatKeyword: TokenSyntax = .keyword(.repeat), + _ unexpectedBetweenRepeatKeywordAndPatternType: UnexpectedNodesSyntax? = nil, + patternType: P, + _ unexpectedAfterPatternType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1754,7 +1789,7 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenRepeatKeywordAndPatternType, patternType, unexpectedAfterPatternType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeRepeatKeyword?.raw, repeatKeyword.raw, @@ -1763,12 +1798,13 @@ public struct PackExpansionTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterPatternType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.packExpansionType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.packExpansionType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1837,8 +1873,8 @@ public struct PackReferenceTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .packReferenceType else { - return nil + guard node.raw.kind == .packReferenceType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1852,12 +1888,12 @@ public struct PackReferenceTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? = nil, - eachKeyword: TokenSyntax = .keyword(.each), - _ unexpectedBetweenEachKeywordAndPackType: UnexpectedNodesSyntax? = nil, - packType: P, - _ unexpectedAfterPackType: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeEachKeyword: UnexpectedNodesSyntax? = nil, + eachKeyword: TokenSyntax = .keyword(.each), + _ unexpectedBetweenEachKeywordAndPackType: UnexpectedNodesSyntax? = nil, + packType: P, + _ unexpectedAfterPackType: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1869,7 +1905,7 @@ public struct PackReferenceTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenEachKeywordAndPackType, packType, unexpectedAfterPackType - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeEachKeyword?.raw, eachKeyword.raw, @@ -1878,12 +1914,13 @@ public struct PackReferenceTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterPackType?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.packReferenceType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.packReferenceType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -1952,8 +1989,8 @@ public struct SimpleTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .simpleTypeIdentifier else { - return nil + guard node.raw.kind == .simpleTypeIdentifier else { + return nil } self._syntaxNode = node._syntaxNode } @@ -1967,12 +2004,12 @@ public struct SimpleTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, - name: TokenSyntax, - _ unexpectedBetweenNameAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, - genericArgumentClause: GenericArgumentClauseSyntax? = nil, - _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeName: UnexpectedNodesSyntax? = nil, + name: TokenSyntax, + _ unexpectedBetweenNameAndGenericArgumentClause: UnexpectedNodesSyntax? = nil, + genericArgumentClause: GenericArgumentClauseSyntax? = nil, + _ unexpectedAfterGenericArgumentClause: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -1984,7 +2021,7 @@ public struct SimpleTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenNameAndGenericArgumentClause, genericArgumentClause, unexpectedAfterGenericArgumentClause - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeName?.raw, name.raw, @@ -1993,12 +2030,13 @@ public struct SimpleTypeIdentifierSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterGenericArgumentClause?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.simpleTypeIdentifier, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.simpleTypeIdentifier, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2067,8 +2105,8 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { public let _syntaxNode: Syntax public init?(_ node: S) { - guard node.raw.kind == .tupleType else { - return nil + guard node.raw.kind == .tupleType else { + return nil } self._syntaxNode = node._syntaxNode } @@ -2082,14 +2120,14 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { } public init( - leadingTrivia: Trivia? = nil, - _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, - leftParen: TokenSyntax = .leftParenToken(), - _ unexpectedBetweenLeftParenAndElements: UnexpectedNodesSyntax? = nil, - elements: TupleTypeElementListSyntax, - _ unexpectedBetweenElementsAndRightParen: UnexpectedNodesSyntax? = nil, - rightParen: TokenSyntax = .rightParenToken(), - _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, + leadingTrivia: Trivia? = nil, + _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil, + leftParen: TokenSyntax = .leftParenToken(), + _ unexpectedBetweenLeftParenAndElements: UnexpectedNodesSyntax? = nil, + elements: TupleTypeElementListSyntax, + _ unexpectedBetweenElementsAndRightParen: UnexpectedNodesSyntax? = nil, + rightParen: TokenSyntax = .rightParenToken(), + _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil, trailingTrivia: Trivia? = nil ) { @@ -2103,7 +2141,7 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedBetweenElementsAndRightParen, rightParen, unexpectedAfterRightParen - ))) {(arena, _) in + ))) {(arena, _) in let layout: [RawSyntax?] = [ unexpectedBeforeLeftParen?.raw, leftParen.raw, @@ -2114,12 +2152,13 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { unexpectedAfterRightParen?.raw ] let raw = RawSyntax.makeLayout( - kind: SyntaxKind.tupleType, - from: layout, - arena: arena, - leadingTrivia: leadingTrivia, - trailingTrivia: trailingTrivia - ) + kind: SyntaxKind.tupleType, + from: layout, + arena: arena, + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia + + ) return SyntaxData.forRoot(raw) } self.init(data) @@ -2173,8 +2212,8 @@ public struct TupleTypeSyntax: TypeSyntaxProtocol, SyntaxHashable { if let col = raw.layoutView!.children[3] { collection = col.layoutView!.appending(element.raw, arena: arena) } else { - collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, - from: [element.raw], arena: arena) + collection = RawSyntax.makeLayout(kind: SyntaxKind.tupleTypeElementList, + from: [element.raw], arena: arena) } let newData = data.replacingChild(at: 3, with: collection, arena: arena) return TupleTypeSyntax(newData) diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift index 999740263a7..429eb5f6617 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableCollectionNodes.swift @@ -178,9 +178,9 @@ extension EnumCaseParameterListSyntax: ExpressibleByArrayLiteral { /// A list of expressions connected by operators. This list is contained by a `SequenceExprSyntax`. extension ExprListSyntax: ExpressibleByArrayLiteral { public init(_ elements: [ExprSyntaxProtocol]) { - self = ExprListSyntax(elements.map { - ExprSyntax(fromProtocol: $0) - }) + self = ExprListSyntax(elements.map { + ExprSyntax(fromProtocol: $0) + }) } public init(arrayLiteral elements: ExprSyntaxProtocol...) { @@ -338,9 +338,9 @@ extension TupleTypeElementListSyntax: ExpressibleByArrayLiteral { /// A collection of syntax nodes that occurred in the source code but could not be used to form a valid syntax tree. extension UnexpectedNodesSyntax: ExpressibleByArrayLiteral { public init(_ elements: [SyntaxProtocol]) { - self = UnexpectedNodesSyntax(elements.map { - Syntax(fromProtocol: $0) - }) + self = UnexpectedNodesSyntax(elements.map { + Syntax(fromProtocol: $0) + }) } public init(arrayLiteral elements: SyntaxProtocol...) { diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift index 30439c02e73..6c6984730d8 100644 --- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift +++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift @@ -46,8 +46,8 @@ extension AccessorDeclSyntax { unexpectedBetweenParameterAndEffectSpecifiers, effectSpecifiers: effectSpecifiers, unexpectedBetweenEffectSpecifiersAndBody, - body: bodyBuilder().map { - CodeBlockSyntax(statements: $0) + body: bodyBuilder().map { + CodeBlockSyntax(statements: $0) }, unexpectedAfterBody, trailingTrivia: trailingTrivia @@ -335,8 +335,8 @@ extension DeinitializerDeclSyntax { unexpectedBetweenModifiersAndDeinitKeyword, deinitKeyword: deinitKeyword, unexpectedBetweenDeinitKeywordAndBody, - body: bodyBuilder().map { - CodeBlockSyntax(statements: $0) + body: bodyBuilder().map { + CodeBlockSyntax(statements: $0) }, unexpectedAfterBody, trailingTrivia: trailingTrivia @@ -663,8 +663,8 @@ extension FunctionDeclSyntax { unexpectedBetweenSignatureAndGenericWhereClause, genericWhereClause: genericWhereClause, unexpectedBetweenGenericWhereClauseAndBody, - body: bodyBuilder().map { - CodeBlockSyntax(statements: $0) + body: bodyBuilder().map { + CodeBlockSyntax(statements: $0) }, unexpectedAfterBody, trailingTrivia: trailingTrivia @@ -867,8 +867,8 @@ extension InitializerDeclSyntax { unexpectedBetweenSignatureAndGenericWhereClause, genericWhereClause: genericWhereClause, unexpectedBetweenGenericWhereClauseAndBody, - body: bodyBuilder().map { - CodeBlockSyntax(statements: $0) + body: bodyBuilder().map { + CodeBlockSyntax(statements: $0) }, unexpectedAfterBody, trailingTrivia: trailingTrivia diff --git a/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift b/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift index 9711f368334..9b7db84da0d 100644 --- a/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift +++ b/Sources/SwiftSyntaxBuilder/generated/ResultBuilders.swift @@ -31,8 +31,8 @@ public struct AccessPathBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -44,8 +44,8 @@ public struct AccessPathBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -69,8 +69,8 @@ public struct AccessPathBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -111,8 +111,8 @@ public struct AccessorListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -124,8 +124,8 @@ public struct AccessorListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -149,8 +149,8 @@ public struct AccessorListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -191,8 +191,8 @@ public struct ArrayElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -204,8 +204,8 @@ public struct ArrayElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -229,8 +229,8 @@ public struct ArrayElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -245,8 +245,8 @@ public struct ArrayElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -274,8 +274,8 @@ public struct AttributeListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -299,8 +299,8 @@ public struct AttributeListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -324,8 +324,8 @@ public struct AttributeListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -366,8 +366,8 @@ public struct AvailabilitySpecListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -379,8 +379,8 @@ public struct AvailabilitySpecListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -404,8 +404,8 @@ public struct AvailabilitySpecListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -446,8 +446,8 @@ public struct AvailabilityVersionRestrictionListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -459,8 +459,8 @@ public struct AvailabilityVersionRestrictionListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -484,8 +484,8 @@ public struct AvailabilityVersionRestrictionListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -526,8 +526,8 @@ public struct CaseItemListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -539,8 +539,8 @@ public struct CaseItemListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -564,8 +564,8 @@ public struct CaseItemListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -580,8 +580,8 @@ public struct CaseItemListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -609,8 +609,8 @@ public struct CatchClauseListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -622,8 +622,8 @@ public struct CatchClauseListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -647,8 +647,8 @@ public struct CatchClauseListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -689,8 +689,8 @@ public struct CatchItemListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -702,8 +702,8 @@ public struct CatchItemListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -727,8 +727,8 @@ public struct CatchItemListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -743,8 +743,8 @@ public struct CatchItemListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -772,8 +772,8 @@ public struct ClosureCaptureItemListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -785,8 +785,8 @@ public struct ClosureCaptureItemListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -810,8 +810,8 @@ public struct ClosureCaptureItemListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -826,8 +826,8 @@ public struct ClosureCaptureItemListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -855,8 +855,8 @@ public struct ClosureParamListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -868,8 +868,8 @@ public struct ClosureParamListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -893,8 +893,8 @@ public struct ClosureParamListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -909,8 +909,8 @@ public struct ClosureParamListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -938,8 +938,8 @@ public struct ClosureParameterListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -951,8 +951,8 @@ public struct ClosureParameterListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -976,8 +976,8 @@ public struct ClosureParameterListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -992,8 +992,8 @@ public struct ClosureParameterListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1021,8 +1021,8 @@ public struct CodeBlockItemListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1034,8 +1034,8 @@ public struct CodeBlockItemListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1059,8 +1059,8 @@ public struct CodeBlockItemListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1101,8 +1101,8 @@ public struct CompositionTypeElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1114,8 +1114,8 @@ public struct CompositionTypeElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1139,8 +1139,8 @@ public struct CompositionTypeElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1181,8 +1181,8 @@ public struct ConditionElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1194,8 +1194,8 @@ public struct ConditionElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1219,8 +1219,8 @@ public struct ConditionElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1235,8 +1235,8 @@ public struct ConditionElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1264,8 +1264,8 @@ public struct DeclNameArgumentListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1277,8 +1277,8 @@ public struct DeclNameArgumentListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1302,8 +1302,8 @@ public struct DeclNameArgumentListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1344,8 +1344,8 @@ public struct DesignatedTypeListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1357,8 +1357,8 @@ public struct DesignatedTypeListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1382,8 +1382,8 @@ public struct DesignatedTypeListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1424,8 +1424,8 @@ public struct DictionaryElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1437,8 +1437,8 @@ public struct DictionaryElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1462,8 +1462,8 @@ public struct DictionaryElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1478,8 +1478,8 @@ public struct DictionaryElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1507,8 +1507,8 @@ public struct DifferentiabilityParamListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1520,8 +1520,8 @@ public struct DifferentiabilityParamListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1545,8 +1545,8 @@ public struct DifferentiabilityParamListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1561,8 +1561,8 @@ public struct DifferentiabilityParamListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1590,8 +1590,8 @@ public struct DocumentationAttributeArgumentsBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1603,8 +1603,8 @@ public struct DocumentationAttributeArgumentsBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1628,8 +1628,8 @@ public struct DocumentationAttributeArgumentsBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1644,8 +1644,8 @@ public struct DocumentationAttributeArgumentsBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1673,8 +1673,8 @@ public struct EffectsArgumentsBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1686,8 +1686,8 @@ public struct EffectsArgumentsBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1711,8 +1711,8 @@ public struct EffectsArgumentsBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1753,8 +1753,8 @@ public struct EnumCaseElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1766,8 +1766,8 @@ public struct EnumCaseElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1791,8 +1791,8 @@ public struct EnumCaseElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1807,8 +1807,8 @@ public struct EnumCaseElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1836,8 +1836,8 @@ public struct EnumCaseParameterListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1849,8 +1849,8 @@ public struct EnumCaseParameterListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1874,8 +1874,8 @@ public struct EnumCaseParameterListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1890,8 +1890,8 @@ public struct EnumCaseParameterListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -1919,8 +1919,8 @@ public struct ExprListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1932,8 +1932,8 @@ public struct ExprListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -1957,8 +1957,8 @@ public struct ExprListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -1999,8 +1999,8 @@ public struct FunctionParameterListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2012,8 +2012,8 @@ public struct FunctionParameterListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2037,8 +2037,8 @@ public struct FunctionParameterListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2053,8 +2053,8 @@ public struct FunctionParameterListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -2082,8 +2082,8 @@ public struct GenericArgumentListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2095,8 +2095,8 @@ public struct GenericArgumentListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2120,8 +2120,8 @@ public struct GenericArgumentListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2136,8 +2136,8 @@ public struct GenericArgumentListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -2165,8 +2165,8 @@ public struct GenericParameterListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2178,8 +2178,8 @@ public struct GenericParameterListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2203,8 +2203,8 @@ public struct GenericParameterListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2219,8 +2219,8 @@ public struct GenericParameterListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -2248,8 +2248,8 @@ public struct GenericRequirementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2261,8 +2261,8 @@ public struct GenericRequirementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2286,8 +2286,8 @@ public struct GenericRequirementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2302,8 +2302,8 @@ public struct GenericRequirementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -2331,8 +2331,8 @@ public struct IfConfigClauseListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2344,8 +2344,8 @@ public struct IfConfigClauseListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2369,8 +2369,8 @@ public struct IfConfigClauseListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2411,8 +2411,8 @@ public struct InheritedTypeListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2424,8 +2424,8 @@ public struct InheritedTypeListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2449,8 +2449,8 @@ public struct InheritedTypeListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2465,8 +2465,8 @@ public struct InheritedTypeListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -2494,8 +2494,8 @@ public struct KeyPathComponentListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2507,8 +2507,8 @@ public struct KeyPathComponentListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2532,8 +2532,8 @@ public struct KeyPathComponentListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2574,8 +2574,8 @@ public struct MemberDeclListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2587,8 +2587,8 @@ public struct MemberDeclListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2612,8 +2612,8 @@ public struct MemberDeclListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2654,8 +2654,8 @@ public struct ModifierListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2667,8 +2667,8 @@ public struct ModifierListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2692,8 +2692,8 @@ public struct ModifierListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2734,8 +2734,8 @@ public struct MultipleTrailingClosureElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2747,8 +2747,8 @@ public struct MultipleTrailingClosureElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2772,8 +2772,8 @@ public struct MultipleTrailingClosureElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2814,8 +2814,8 @@ public struct ObjCSelectorBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2827,8 +2827,8 @@ public struct ObjCSelectorBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2852,8 +2852,8 @@ public struct ObjCSelectorBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2894,8 +2894,8 @@ public struct PatternBindingListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2907,8 +2907,8 @@ public struct PatternBindingListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -2932,8 +2932,8 @@ public struct PatternBindingListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -2948,8 +2948,8 @@ public struct PatternBindingListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -2977,8 +2977,8 @@ public struct PrecedenceGroupAttributeListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3008,8 +3008,8 @@ public struct PrecedenceGroupAttributeListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3033,8 +3033,8 @@ public struct PrecedenceGroupAttributeListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3075,8 +3075,8 @@ public struct PrecedenceGroupNameListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3088,8 +3088,8 @@ public struct PrecedenceGroupNameListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3113,8 +3113,8 @@ public struct PrecedenceGroupNameListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3155,8 +3155,8 @@ public struct PrimaryAssociatedTypeListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3168,8 +3168,8 @@ public struct PrimaryAssociatedTypeListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3193,8 +3193,8 @@ public struct PrimaryAssociatedTypeListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3209,8 +3209,8 @@ public struct PrimaryAssociatedTypeListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -3238,8 +3238,8 @@ public struct SpecializeAttributeSpecListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3275,8 +3275,8 @@ public struct SpecializeAttributeSpecListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3300,8 +3300,8 @@ public struct SpecializeAttributeSpecListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3342,8 +3342,8 @@ public struct StringLiteralSegmentsBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3367,8 +3367,8 @@ public struct StringLiteralSegmentsBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3392,8 +3392,8 @@ public struct StringLiteralSegmentsBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3434,8 +3434,8 @@ public struct SwitchCaseListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3459,8 +3459,8 @@ public struct SwitchCaseListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3484,8 +3484,8 @@ public struct SwitchCaseListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3526,8 +3526,8 @@ public struct TupleExprElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3539,8 +3539,8 @@ public struct TupleExprElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3564,8 +3564,8 @@ public struct TupleExprElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3580,8 +3580,8 @@ public struct TupleExprElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -3609,8 +3609,8 @@ public struct TuplePatternElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3622,8 +3622,8 @@ public struct TuplePatternElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3647,8 +3647,8 @@ public struct TuplePatternElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3663,8 +3663,8 @@ public struct TuplePatternElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -3692,8 +3692,8 @@ public struct TupleTypeElementListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3705,8 +3705,8 @@ public struct TupleTypeElementListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3730,8 +3730,8 @@ public struct TupleTypeElementListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3746,8 +3746,8 @@ public struct TupleTypeElementListBuilder { /// block statement to produce the final returned result. public static func buildFinalResult(_ component: Component) -> FinalResult { let lastIndex = component.count - 1 - return .init(component.enumerated().map { index, source in - return index < lastIndex ? source.ensuringTrailingComma() : source + return .init(component.enumerated().map { index, source in + return index < lastIndex ? source.ensuringTrailingComma() : source }) } } @@ -3775,8 +3775,8 @@ public struct UnexpectedNodesBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3788,8 +3788,8 @@ public struct UnexpectedNodesBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3813,8 +3813,8 @@ public struct UnexpectedNodesBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3855,8 +3855,8 @@ public struct YieldExprListBuilder { /// Required by every result builder to build combined results from /// statement blocks. public static func buildBlock(_ components: Self.Component...) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } @@ -3868,8 +3868,8 @@ public struct YieldExprListBuilder { /// Add all the elements of `expression` to this result builder, effectively flattening them. public static func buildExpression(_ expression: Self.FinalResult) -> Self.Component { - return expression.map { - $0 + return expression.map { + $0 } } @@ -3893,8 +3893,8 @@ public struct YieldExprListBuilder { /// Enables support for 'for..in' loops by combining the /// results of all iterations into a single result. public static func buildArray(_ components: [Self.Component]) -> Self.Component { - return components.flatMap { - $0 + return components.flatMap { + $0 } } diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift index c33ef072662..74ec2450258 100644 --- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift +++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift @@ -20,9 +20,9 @@ extension SyntaxParseable { public typealias StringInterpolation = SyntaxStringInterpolation public init(stringInterpolation: SyntaxStringInterpolation) { - self = performParse(source: stringInterpolation.sourceText, parse: { parser in - return Self.parse(from: &parser) - }) + self = performParse(source: stringInterpolation.sourceText, parse: { parser in + return Self.parse(from: &parser) + }) } } @@ -60,7 +60,7 @@ extension TypeSyntax: SyntaxExpressibleByStringInterpolation {} // but is currently used in `ConvenienceInitializers.swift`. // See the corresponding TODO there. func performParse(source: [UInt8], parse: (inout Parser) -> SyntaxType) -> SyntaxType { - return source.withUnsafeBufferPointer { buffer in + return source.withUnsafeBufferPointer { buffer in var parser = Parser(buffer) // FIXME: When the parser supports incremental parsing, put the // interpolatedSyntaxNodes in so we don't have to parse them again. diff --git a/Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift b/Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift index d5e9c59608e..c11f3310656 100644 --- a/Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift +++ b/Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift @@ -115,11 +115,23 @@ public struct SubtreeMatcher { afterMarker: String? = nil, _ expected: Syntax, includeTrivia: Bool = false, + additionalInfo: String? = nil, file: StaticString = #filePath, line: UInt = #line ) throws { if let diff = try findFirstDifference(afterMarker: afterMarker, baseline: expected, includeTrivia: includeTrivia) { - XCTFail(diff.debugDescription, file: file, line: line) + let message: String + if let additionalInfo = additionalInfo { + message = """ + \(additionalInfo) + + \(diff.debugDescription) + """ + } else { + message = diff.debugDescription + } + + XCTFail(message, file: file, line: line) } } } diff --git a/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift b/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift index 21ac942154f..69f6be18ccd 100644 --- a/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift +++ b/Sources/_SwiftSyntaxTestSupport/SyntaxProtocol+Initializer.swift @@ -15,10 +15,12 @@ import SwiftBasicFormat import SwiftSyntaxBuilder private class InitializerExprFormat: BasicFormat { - override var indentation: TriviaPiece { return .spaces(indentationLevel * 2) } + public init() { + super.init(indentationWidth: .spaces(2)) + } private func formatChildrenSeparatedByNewline(children: SyntaxChildren, elementType: SyntaxType.Type) -> [SyntaxType] { - indentationLevel += 1 + increaseIndentationLevel() var formattedChildren = children.map { self.visit($0).as(SyntaxType.self)! } @@ -26,12 +28,12 @@ private class InitializerExprFormat: BasicFormat { if $0.leadingTrivia.first?.isNewline == true { return $0 } else { - return $0.with(\.leadingTrivia, indentedNewline + $0.leadingTrivia) + return $0.with(\.leadingTrivia, .newline + currentIndentationLevel + $0.leadingTrivia) } } - indentationLevel -= 1 + decreaseIndentationLevel() if !formattedChildren.isEmpty { - formattedChildren[formattedChildren.count - 1] = formattedChildren[formattedChildren.count - 1].with(\.trailingTrivia, indentedNewline) + formattedChildren[formattedChildren.count - 1] = formattedChildren[formattedChildren.count - 1].with(\.trailingTrivia, .newline + currentIndentationLevel) } return formattedChildren } diff --git a/Tests/SwiftBasicFormatTest/BasicFormatTests.swift b/Tests/SwiftBasicFormatTest/BasicFormatTests.swift new file mode 100644 index 00000000000..58a556c0917 --- /dev/null +++ b/Tests/SwiftBasicFormatTest/BasicFormatTests.swift @@ -0,0 +1,260 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// + +import SwiftBasicFormat +import SwiftParser +import SwiftSyntaxBuilder +import SwiftSyntax + +import XCTest +import _SwiftSyntaxTestSupport + +fileprivate func assertFormatted( + source: String, + expected: String, + file: StaticString = #file, + line: UInt = #line +) { + assertStringsEqualWithDiff(Parser.parse(source: source).formatted().description, expected, file: file, line: line) +} + +final class BasicFormatTest: XCTestCase { + func testNotIndented() { + assertFormatted( + source: """ + func foo() { + someFunc(a: 1, + b: 1) + } + """, + expected: """ + func foo() { + someFunc(a: 1, + b: 1) + } + """ + ) + } + + func testPartialIndent() { + assertFormatted( + source: """ + func foo() { + someFunc(a: 1, + b: 1) + } + """, + expected: """ + func foo() { + someFunc(a: 1, + b: 1) + } + """ + ) + } + + func testPartialIndentNested() { + assertFormatted( + source: """ + func outer() { + func inner() { + someFunc(a: 1, + b: 1) + } + } + """, + expected: """ + func outer() { + func inner() { + someFunc(a: 1, + b: 1) + } + } + """ + ) + } + + func testAlreadyIndented() { + let source = """ + func foo() { + someFunc(a: 1, + b: 1) + } + """ + + assertFormatted(source: source, expected: source) + } + + func testAlreadyIndentedWithComment() { + let source = """ + func foo() { + // ABC + someFunc(a: 1, + b: 1) + } + """ + + assertFormatted(source: source, expected: source) + } + + func testAlreadyIndentedWithComment2() { + assertFormatted( + source: """ + func foo() { + // ABC + someFunc(a: 1, + b: 1) + } + """, + expected: """ + func foo() { + // ABC + someFunc(a: 1, + b: 1) + } + """ + ) + } + + func testClosureIndentationArgBefore() { + assertFormatted( + source: """ + someFunc(arg2: 1, + closure: { arg in indented() }) + """, + expected: """ + someFunc(arg2: 1, + closure: { arg in + indented() + }) + """ + ) + } + + func testClosureIndentationAfter() { + assertFormatted( + source: """ + someFunc(closure: { arg in indented() }, + arg2: 1) + """, + expected: """ + someFunc(closure: { arg in + indented() + }, + arg2: 1) + """ + ) + } + + func testLineWrappingInsideIndentedBlock() { + assertFormatted( + source: """ + public init?(errorCode: Int) { + guard errorCode > 0 else { return nil } + self.code = errorCode + } + """, + expected: """ + public init?(errorCode: Int) { + guard errorCode > 0 else { + return nil + } + self.code = errorCode + } + """ + ) + } + + func testCustomIndentationInBlockThatDoesntHaveNewline() { + assertFormatted( + source: """ + extension MyType {func buildSyntax(format: Format) -> Syntax { + return Syntax(buildTest(format: format)) + }} + """, + expected: """ + extension MyType { + func buildSyntax(format: Format) -> Syntax { + return Syntax(buildTest(format: format)) + } + } + """ + ) + } + + func testStringInterpolationAtStartOfMultiLineStringLiteral() { + assertFormatted( + source: #""" + class Foo { + func test() { + assertionFailure(""" + ABC + \(myVar) + """) + } + } + """#, + expected: #""" + class Foo { + func test() { + assertionFailure(""" + ABC + \(myVar) + """) + } + } + """# + ) + } + + func testMultilineStringLiteral() { + assertFormatted( + source: #""" + assertionFailure(""" + First line + Second line + """) + """#, + expected: #""" + assertionFailure(""" + First line + Second line + """) + """# + ) + } + + func testNestedUserDefinedIndentation() { + assertFormatted( + source: """ + class X { + func test() { + withTrailingClosure() { + if true { return } + } + } + } + """, + expected: """ + class X { + func test() { + withTrailingClosure() { + if true { + return + } + } + } + } + """ + ) + } +} diff --git a/Tests/SwiftIDEUtilsTest/ClassificationTests.swift b/Tests/SwiftIDEUtilsTest/ClassificationTests.swift index 7d18d05b999..8982cbd7f2e 100644 --- a/Tests/SwiftIDEUtilsTest/ClassificationTests.swift +++ b/Tests/SwiftIDEUtilsTest/ClassificationTests.swift @@ -117,8 +117,8 @@ public class ClassificationTests: XCTestCase { let tree = Parser.parse(source: source) do { let tokens = Array(tree.tokens(viewMode: .sourceAccurate)) - XCTAssertEqual(tokens.count, 4) - guard tokens.count == 4 else { + XCTAssertEqual(tokens.count, 5) + guard tokens.count == 5 else { return } let classif = tokens.map { $0.tokenClassification } @@ -130,6 +130,8 @@ public class ClassificationTests: XCTestCase { XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 5, length: 1)) XCTAssertEqual(classif[3].kind, .typeIdentifier) XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 7, length: 3)) + XCTAssertEqual(classif[4].kind, .none) + XCTAssertEqual(classif[4].range, ByteSourceRange(offset: 10, length: 0)) } do { let tok = tree.lastToken(viewMode: .sourceAccurate)!.previousToken(viewMode: .sourceAccurate)! @@ -145,8 +147,8 @@ public class ClassificationTests: XCTestCase { let tree = Parser.parse(source: source) let tokens = Array(tree.tokens(viewMode: .sourceAccurate)) - XCTAssertEqual(tokens.count, 10) - guard tokens.count == 10 else { + XCTAssertEqual(tokens.count, 11) + guard tokens.count == 11 else { return } let classif = tokens.map { $0.tokenClassification } @@ -170,6 +172,8 @@ public class ClassificationTests: XCTestCase { XCTAssertEqual(classif[8].range, ByteSourceRange(offset: 19, length: 1)) XCTAssertEqual(classif[9].kind, .integerLiteral) XCTAssertEqual(classif[9].range, ByteSourceRange(offset: 21, length: 1)) + XCTAssertEqual(classif[10].kind, .none) + XCTAssertEqual(classif[10].range, ByteSourceRange(offset: 22, length: 0)) } do { @@ -177,8 +181,8 @@ public class ClassificationTests: XCTestCase { let tree = Parser.parse(source: source) let tokens = Array(tree.tokens(viewMode: .sourceAccurate)) - XCTAssertEqual(tokens.count, 3) - guard tokens.count == 3 else { + XCTAssertEqual(tokens.count, 4) + guard tokens.count == 4 else { return } let classif = tokens.map { $0.tokenClassification } @@ -188,6 +192,8 @@ public class ClassificationTests: XCTestCase { XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 6, length: 8)) XCTAssertEqual(classif[2].kind, .operatorIdentifier) XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 15, length: 4)) + XCTAssertEqual(classif[3].kind, .none) + XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 19, length: 0)) } } } diff --git a/Tests/SwiftParserTest/Assertions.swift b/Tests/SwiftParserTest/Assertions.swift index 3eadf00c5e0..cd75fcf49e5 100644 --- a/Tests/SwiftParserTest/Assertions.swift +++ b/Tests/SwiftParserTest/Assertions.swift @@ -625,6 +625,10 @@ func assertParse( ) } + if expectedDiagnostics.isEmpty { + assertBasicFormat(source: source, parse: parse, file: file, line: line) + } + #if SWIFTPARSER_ENABLE_ALTERNATE_TOKEN_INTROSPECTION if enableTestCaseMutation { let mutations: [(offset: Int, replacement: TokenSpec)] = parser.alternativeTokenChoices.flatMap { offset, replacements in @@ -659,3 +663,54 @@ func assertParse( } #endif } + +class TriviaRemover: SyntaxRewriter { + override func visit(_ token: TokenSyntax) -> TokenSyntax { + var ancestor = Syntax(token) + while let parent = ancestor.parent { + ancestor = parent + if ancestor.is(StringLiteralExprSyntax.self) || ancestor.is(RegexLiteralExprSyntax.self) { + // Don't mess with indentation inside string or regex literals. + // BasicFormat doesn't know where to re-apply newlines and how much to indent the string literal contents. + return token + } + } + if token.parent?.is(StringSegmentSyntax.self) ?? false { + return token + } + return token.with(\.leadingTrivia, []).with(\.trailingTrivia, []) + } +} + +func assertBasicFormat( + source: String, + parse: (inout Parser) -> S, + file: StaticString = #file, + line: UInt = #line +) { + var parser = Parser(source) + let sourceTree = Syntax(parse(&parser)) + let withoutTrivia = TriviaRemover().visit(sourceTree) + let formatted = withoutTrivia.formatted() + + var formattedParser = Parser(formatted.description) + let formattedReparsed = Syntax(parse(&formattedParser)) + + do { + let subtreeMatcher = SubtreeMatcher(Syntax(formattedReparsed), markers: [:]) + try subtreeMatcher.assertSameStructure( + Syntax(sourceTree), + includeTrivia: false, + additionalInfo: """ + Removing trivia, formatting using BasicFormat and re-parsing did not produce the same syntax tree. + + Formatted source: + \(formatted) + """, + file: file, + line: line + ) + } catch { + XCTFail("Matching for a subtree failed with error: \(error)", file: file, line: line) + } +} diff --git a/Tests/SwiftParserTest/AttributeTests.swift b/Tests/SwiftParserTest/AttributeTests.swift index 81bc05183c5..900775342ad 100644 --- a/Tests/SwiftParserTest/AttributeTests.swift +++ b/Tests/SwiftParserTest/AttributeTests.swift @@ -27,7 +27,7 @@ final class AttributeTests: XCTestCase { DiagnosticSpec(message: "expected ')' to end attribute", fixIts: ["insert ')'"]), ], fixedSource: """ - @_dynamicReplacement(for : <#identifier#>) + @_dynamicReplacement(for: <#identifier#>) func test_dynamic_replacement_for2() { } """ @@ -311,8 +311,7 @@ final class AttributeTests: XCTestCase { "@resultBuilder1️⃣", diagnostics: [DiagnosticSpec(message: "expected declaration after attribute")], fixedSource: """ - @resultBuilder - <#declaration#> + @resultBuilder <#declaration#> """ ) } diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift index 4f9bcce7563..76a9d8ed9a4 100644 --- a/Tests/SwiftParserTest/DeclarationTests.swift +++ b/Tests/SwiftParserTest/DeclarationTests.swift @@ -1005,7 +1005,8 @@ final class DeclarationTests: XCTestCase { DiagnosticSpec(locationMarker: "2️⃣", message: "expected member block in class"), ], fixedSource: """ - }class C {} + }class C { + } """ ) assertParse( @@ -1363,11 +1364,10 @@ final class DeclarationTests: XCTestCase { assertParse( "protocol1️⃣<2️⃣:3️⃣", diagnostics: [ - DiagnosticSpec(locationMarker: "1️⃣", message: "expected identifier in protocol"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in primary associated type clause"), - DiagnosticSpec(locationMarker: "2️⃣", message: "expected '>' to end primary associated type clause"), - DiagnosticSpec(locationMarker: "3️⃣", message: "expected type in inherited type"), - DiagnosticSpec(locationMarker: "3️⃣", message: "expected member block in protocol"), + DiagnosticSpec(locationMarker: "1️⃣", message: "expected identifier in protocol", fixIts: ["insert identifier"]), + DiagnosticSpec(locationMarker: "2️⃣", message: "expected name and '>' to end primary associated type clause", fixIts: ["insert name and '>'"]), + DiagnosticSpec(locationMarker: "3️⃣", message: "expected type in inherited type", fixIts: ["insert type"]), + DiagnosticSpec(locationMarker: "3️⃣", message: "expected member block in protocol", fixIts: ["insert member block"]), ] ) } diff --git a/Tests/SwiftParserTest/VariadicGenericsTests.swift b/Tests/SwiftParserTest/VariadicGenericsTests.swift index a540b2a09ba..78442f3ceac 100644 --- a/Tests/SwiftParserTest/VariadicGenericsTests.swift +++ b/Tests/SwiftParserTest/VariadicGenericsTests.swift @@ -607,8 +607,11 @@ final class TypeParameterPackTests: XCTestCase { var foo: (Array 1️⃣Array) """, diagnostics: [ - DiagnosticSpec(message: "expected ',' in tuple type") - ] + DiagnosticSpec(message: "expected ',' in tuple type", fixIts: ["insert ','"]) + ], + fixedSource: """ + var foo: (Array, Array) + """ ) assertParse( @@ -625,8 +628,11 @@ final class TypeParameterPackTests: XCTestCase { var foo: (Array 1️⃣a) """, diagnostics: [ - DiagnosticSpec(message: "expected ',' in tuple type") - ] + DiagnosticSpec(message: "expected ',' in tuple type", fixIts: ["insert ','"]) + ], + fixedSource: """ + var foo: (Array, a) + """ ) } } diff --git a/Tests/SwiftParserTest/translated/AvailabilityQueryTests.swift b/Tests/SwiftParserTest/translated/AvailabilityQueryTests.swift index f5e84512990..c2b811ef723 100644 --- a/Tests/SwiftParserTest/translated/AvailabilityQueryTests.swift +++ b/Tests/SwiftParserTest/translated/AvailabilityQueryTests.swift @@ -121,8 +121,7 @@ final class AvailabilityQueryTests: XCTestCase { } """, diagnostics: [ - DiagnosticSpec(message: "expected version restriction in availability argument"), - DiagnosticSpec(message: "expected ')' to end availability condition"), + DiagnosticSpec(message: "expected platform and ')' to end availability condition", fixIts: ["insert platform and ')'"]) ] ) } diff --git a/Tests/SwiftParserTest/translated/AvailabilityQueryUnavailabilityTests.swift b/Tests/SwiftParserTest/translated/AvailabilityQueryUnavailabilityTests.swift index fc9aca876e1..75387992907 100644 --- a/Tests/SwiftParserTest/translated/AvailabilityQueryUnavailabilityTests.swift +++ b/Tests/SwiftParserTest/translated/AvailabilityQueryUnavailabilityTests.swift @@ -90,8 +90,12 @@ final class AvailabilityQueryUnavailabilityTests: XCTestCase { } """, diagnostics: [ - DiagnosticSpec(message: "expected '(', '@availability' arguments, and ')' in availability condition") - ] + DiagnosticSpec(message: "expected '(', '@availability' arguments, and ')' in availability condition", fixIts: ["insert '(', '@availability' arguments, and ')'"]) + ], + fixedSource: """ + if #unavailable(<#identifier#>) { + } + """ ) } @@ -102,9 +106,12 @@ final class AvailabilityQueryUnavailabilityTests: XCTestCase { } """, diagnostics: [ - DiagnosticSpec(message: "expected version restriction in availability argument"), - DiagnosticSpec(message: "expected ')' to end availability condition"), - ] + DiagnosticSpec(message: "expected platform and ')' to end availability condition", fixIts: ["insert platform and ')'"]) + ], + fixedSource: """ + if #unavailable(<#identifier#>) { + } + """ ) } @@ -292,9 +299,13 @@ final class AvailabilityQueryUnavailabilityTests: XCTestCase { } """, diagnostics: [ - DiagnosticSpec(message: "expected version restriction in availability argument"), - DiagnosticSpec(message: "expected ')' to end availability condition"), - ] + DiagnosticSpec(message: "expected version restriction in availability argument", fixIts: ["insert version restriction"]), + DiagnosticSpec(message: "expected ')' to end availability condition", fixIts: ["insert ')'"]), + ], + fixedSource: """ + if #unavailable(OSX 10.51, <#identifier#>) { + } + """ ) } @@ -305,8 +316,12 @@ final class AvailabilityQueryUnavailabilityTests: XCTestCase { } """, diagnostics: [ - DiagnosticSpec(message: "expected version restriction in availability argument") - ] + DiagnosticSpec(message: "expected version restriction in availability argument", fixIts: ["insert version restriction"]) + ], + fixedSource: """ + if #unavailable(OSX 10.51, <#identifier#>) { + } + """ ) } diff --git a/Tests/SwiftParserTest/translated/DiagnoseDynamicReplacementTests.swift b/Tests/SwiftParserTest/translated/DiagnoseDynamicReplacementTests.swift index acba50d0941..89acb14b723 100644 --- a/Tests/SwiftParserTest/translated/DiagnoseDynamicReplacementTests.swift +++ b/Tests/SwiftParserTest/translated/DiagnoseDynamicReplacementTests.swift @@ -65,7 +65,12 @@ final class DiagnoseDynamicReplacementTests: XCTestCase { NoteSpec(message: "to match this opening '('") ] ) - ] + ], + fixedSource: """ + @_dynamicReplacement(for: dynamically_replaceable()) + func test_dynamic_replacement_for3() { + } + """ ) } diff --git a/Tests/SwiftParserTest/translated/InvalidTests.swift b/Tests/SwiftParserTest/translated/InvalidTests.swift index de836932453..0795d48291d 100644 --- a/Tests/SwiftParserTest/translated/InvalidTests.swift +++ b/Tests/SwiftParserTest/translated/InvalidTests.swift @@ -489,7 +489,7 @@ final class InvalidTests: XCTestCase { ], fixedSource: """ func were( - wolf: () ){} + wolf: ()) {} """ ) } diff --git a/Tests/SwiftParserTest/translated/RecoveryTests.swift b/Tests/SwiftParserTest/translated/RecoveryTests.swift index a3c04523276..31889b689c7 100644 --- a/Tests/SwiftParserTest/translated/RecoveryTests.swift +++ b/Tests/SwiftParserTest/translated/RecoveryTests.swift @@ -1031,7 +1031,7 @@ final class RecoveryTests: XCTestCase { assertParse( """ // Note: Don't move braces to a different line here. - struct ErrorGenericParameterList4< 1️⃣ + struct ErrorGenericParameterList4<1️⃣ { } """, @@ -2245,4 +2245,34 @@ final class RecoveryTests: XCTestCase { ) } + // https://github.com/apple/swift-syntax/issues/1483 + func testRecovery183() { + // Can be parsed and produces no diagnostics. + assertParse( + "func f< 1️⃣>() {}", + diagnostics: [ + DiagnosticSpec( + message: "expected generic parameter in generic parameter clause", + fixIts: ["insert generic parameter"] + ) + ], + fixedSource: """ + func f<<#identifier#>>() {} + """ + ) + + // Can be parsed. Printing the node or asking for the diagnostics leads to a crash. + assertParse( + "func f<1️⃣>() {}", + diagnostics: [ + DiagnosticSpec( + message: "expected generic parameter in generic parameter clause", + fixIts: ["insert generic parameter"] + ) + ], + fixedSource: """ + func f<<#identifier#>>() {} + """ + ) + } } diff --git a/Tests/SwiftParserTest/translated/SubscriptingTests.swift b/Tests/SwiftParserTest/translated/SubscriptingTests.swift index a0a98cdadc7..64b33e80d80 100644 --- a/Tests/SwiftParserTest/translated/SubscriptingTests.swift +++ b/Tests/SwiftParserTest/translated/SubscriptingTests.swift @@ -210,7 +210,7 @@ final class SubscriptingTests: XCTestCase { struct A0 { subscript( i : (Int) - -> Int) -> <#type#>{ + -> Int) -> <#type#> { get { return stored } @@ -460,7 +460,7 @@ final class SubscriptingTests: XCTestCase { ], fixedSource: """ struct A11 { - subscript( x y : (Int) -> Int) -> <#type#>{ + subscript(x y : (Int) -> Int) -> <#type#> { return 0 } } diff --git a/Tests/SwiftParserTest/translated/ToplevelLibraryTests.swift b/Tests/SwiftParserTest/translated/ToplevelLibraryTests.swift index 426f39fb098..85fb7aee92b 100644 --- a/Tests/SwiftParserTest/translated/ToplevelLibraryTests.swift +++ b/Tests/SwiftParserTest/translated/ToplevelLibraryTests.swift @@ -46,7 +46,8 @@ final class ToplevelLibraryTests: XCTestCase { DiagnosticSpec(message: "expected 'in', expression, and body in 'for' statement") ], fixedSource: """ - for i in <#expression#> {} + for i in <#expression#> { + } """ ) } diff --git a/Tests/SwiftSyntaxBuilderTest/ArrayExprTests.swift b/Tests/SwiftSyntaxBuilderTest/ArrayExprTests.swift index 6f3f383e841..1b5e2759e79 100644 --- a/Tests/SwiftSyntaxBuilderTest/ArrayExprTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/ArrayExprTests.swift @@ -39,10 +39,10 @@ final class ArrayExprTests: XCTestCase { builder, """ [ - 1, - #"2"3"#, - 4, - "五", + 1, + #"2"3"#, + 4, + "五", ] """ ) diff --git a/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift index d1b45b91bc7..cba089801dc 100644 --- a/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift @@ -52,4 +52,27 @@ final class ClassDeclSyntaxTests: XCTestCase { """ ) } + + func testNodeWithoutAnchorPointInResultBuilder() throws { + let buildable = ClassDeclSyntax(identifier: .identifier("Foo")) { + DeclSyntax( + """ + func foo() -> String { + return "hello world" + } + """ + ) + } + + assertBuildResult( + buildable, + """ + class Foo { + func foo() -> String { + return "hello world" + } + } + """ + ) + } } diff --git a/Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift b/Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift index 74a3ecfa7a0..099990c3c9e 100644 --- a/Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/CollectionNodeFlatteningTests.swift @@ -16,8 +16,6 @@ import SwiftSyntaxBuilder final class CollectionNodeFlatteningTests: XCTestCase { func test_FlattenCodeBlockItemListWithBuilder() { - let leadingTrivia = Trivia.unexpectedText("␣") - @CodeBlockItemListBuilder func buildInnerCodeBlockItemList() -> CodeBlockItemListSyntax { FunctionCallExprSyntax(callee: ExprSyntax("innerBuilder")) @@ -30,7 +28,7 @@ final class CollectionNodeFlatteningTests: XCTestCase { buildInnerCodeBlockItemList() } - let codeBlock = CodeBlockSyntax(leadingTrivia: leadingTrivia) { + let codeBlock = CodeBlockSyntax { FunctionCallExprSyntax(callee: ExprSyntax("outsideBuilder")) buildOuterCodeBlockItemList() } @@ -38,7 +36,7 @@ final class CollectionNodeFlatteningTests: XCTestCase { assertBuildResult( codeBlock, """ - ␣{ + { outsideBuilder() outerBuilder() innerBuilder() diff --git a/Tests/SwiftSyntaxBuilderTest/DictionaryExprTests.swift b/Tests/SwiftSyntaxBuilderTest/DictionaryExprTests.swift index 05a004dd6f5..193792d1a59 100644 --- a/Tests/SwiftSyntaxBuilderTest/DictionaryExprTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/DictionaryExprTests.swift @@ -45,11 +45,11 @@ final class DictionaryExprTests: XCTestCase { builder, """ [ - 1: 1, - 2: "二", - "three": 3, - 4: - #"f"o"u"r"#, + 1: 1, + 2: "二", + "three": 3, + 4: + #"f"o"u"r"#, ] """ ) diff --git a/Tests/SwiftSyntaxBuilderTest/ForInStmtTests.swift b/Tests/SwiftSyntaxBuilderTest/ForInStmtTests.swift index bfce5852a98..149875f85eb 100644 --- a/Tests/SwiftSyntaxBuilderTest/ForInStmtTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/ForInStmtTests.swift @@ -38,7 +38,7 @@ final class ForInStmtTests: XCTestCase { ).cast(ForInStmtSyntax.self), """ for foo in bar { - _ = foo + _ = foo } """ ), diff --git a/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift b/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift index 9f5a8cd6874..3151d7656bf 100644 --- a/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/FunctionTests.swift @@ -63,7 +63,7 @@ final class FunctionTests: XCTestCase { ), """ public static func == (lhs: String, rhs: String) -> Bool { - return lhs < rhs + return lhs < rhs } """ ), @@ -77,7 +77,7 @@ final class FunctionTests: XCTestCase { ), """ public static func == (lhs: String, rhs: String) -> Bool { - return lhs > rhs + return lhs > rhs } """ ), @@ -91,7 +91,7 @@ final class FunctionTests: XCTestCase { ), """ public static func == (lhs1: String, lhs2: String, rhs1: String, rhs2: String) -> Bool { - return (lhs1, lhs2) > (rhs1, rhs2) + return (lhs1, lhs2) > (rhs1, rhs2) } """ ), @@ -105,7 +105,7 @@ final class FunctionTests: XCTestCase { ), """ public func foo(input: Bas) -> Foo { - return input as Foo! + return input as Foo! } """ ), @@ -119,7 +119,7 @@ final class FunctionTests: XCTestCase { ), """ public func foo(input: Bas) -> Foo { - return input as Foo! + return input as Foo! } """ ), @@ -133,7 +133,7 @@ final class FunctionTests: XCTestCase { ), """ public func foo(input: [Bar]) -> Foo<[Bar]> { - return input + return input } """ ), @@ -147,7 +147,7 @@ final class FunctionTests: XCTestCase { ), """ public func foo(myOptionalClosure: MyClosure?) { - myOptionalClosure!() + myOptionalClosure!() } """ ), @@ -290,13 +290,13 @@ final class FunctionTests: XCTestCase { builder, """ func test( - _ p1: Int, - p2: Int, - _ p3: Int, - p4: Int, - _ p5: Int + _ p1: Int, + p2: Int, + _ p3: Int, + p4: Int, + _ p5: Int ) -> Int { - return p1 + p2 + p3 + p4 + p5 + return p1 + p2 + p3 + p4 + p5 } """ ) diff --git a/Tests/SwiftSyntaxBuilderTest/IfConfigDeclSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/IfConfigDeclSyntaxTests.swift index 226bee15f34..20bd7f27945 100644 --- a/Tests/SwiftSyntaxBuilderTest/IfConfigDeclSyntaxTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/IfConfigDeclSyntaxTests.swift @@ -56,11 +56,11 @@ final class IfConfigDeclSyntaxTests: XCTestCase { """ #if DEBUG public func debug(_ data: Foo) -> String { - return data.debugDescription + return data.debugDescription } #else public func debug(_ data: Foo) -> String { - return data.description + return data.description } #endif """ diff --git a/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift b/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift index 802a37b88c3..3e954bb342c 100644 --- a/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/IfStmtTests.swift @@ -41,7 +41,7 @@ final class IfStmtTests: XCTestCase { ).cast(IfExprSyntax.self), """ if foo == x { - return foo + return foo } """ ), @@ -58,10 +58,10 @@ final class IfStmtTests: XCTestCase { ).cast(IfExprSyntax.self), """ if foo == x { - return foo + return foo } else { - return bar + return bar } """ ), diff --git a/Tests/SwiftSyntaxBuilderTest/InitializerDeclTests.swift b/Tests/SwiftSyntaxBuilderTest/InitializerDeclTests.swift index bc80a703c5d..8b8b17e6226 100644 --- a/Tests/SwiftSyntaxBuilderTest/InitializerDeclTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/InitializerDeclTests.swift @@ -28,7 +28,7 @@ final class InitializerDeclTests: XCTestCase { builder, """ public init(errorCode: Int) { - self.code = errorCode + self.code = errorCode } """ ) @@ -48,10 +48,10 @@ final class InitializerDeclTests: XCTestCase { builder, """ public init?(errorCode: Int) { - guard errorCode > 0 else { - return nil - } - self.code = errorCode + guard errorCode > 0 else { + return nil + } + self.code = errorCode } """ ) @@ -76,13 +76,13 @@ final class InitializerDeclTests: XCTestCase { builder, """ init( - _ p1: Int, - p2: Int, - _ p3: Int, - p4: Int, - _ p5: Int + _ p1: Int, + p2: Int, + _ p3: Int, + p4: Int, + _ p5: Int ) { - self.init(p1 + p2 + p3 + p4 + p5) + self.init(p1 + p2 + p3 + p4 + p5) } """ ) diff --git a/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift b/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift index 35e7af26829..f195e2bbb1b 100644 --- a/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift @@ -19,8 +19,8 @@ import SwiftBasicFormat import XCTest class TwoSpacesFormat: BasicFormat { - override var indentation: TriviaPiece { - .spaces(indentationLevel * 2) + public init() { + super.init(indentationWidth: .spaces(2)) } } diff --git a/Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift b/Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift index 76da43a3cf3..1de0bf7a62b 100644 --- a/Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift +++ b/Tests/SwiftSyntaxBuilderTest/StringLiteralTests.swift @@ -268,11 +268,11 @@ final class StringLiteralTests: XCTestCase { buildable, #""" assertionFailure(""" - Error validating child at index \(index) of \(nodeKind): - Node did not satisfy any node choice requirement. - Validation failures: - \(nonNilErrors.map({ "- \($0.description)" }).joined(separator: "\n")) - """, file: file, line: line) + Error validating child at index \(index) of \(nodeKind): + Node did not satisfy any node choice requirement. + Validation failures: + \(nonNilErrors.map({ "- \($0.description)" }).joined(separator: "\n")) + """, file: file, line: line) """# ) } @@ -294,11 +294,11 @@ final class StringLiteralTests: XCTestCase { buildable, #""" if true { - assertionFailure(""" - Error validating child at index - Node did not satisfy any node choice requirement. - Validation failures: - """) + assertionFailure(""" + Error validating child at index + Node did not satisfy any node choice requirement. + Validation failures: + """) } """# ) @@ -323,13 +323,13 @@ final class StringLiteralTests: XCTestCase { buildable, #""" if true { - assertionFailure( - """ - Error validating child at index - Node did not satisfy any node choice requirement. - Validation failures: - """ - ) + assertionFailure( + """ + Error validating child at index + Node did not satisfy any node choice requirement. + Validation failures: + """ + ) } """# ) diff --git a/Tests/SwiftSyntaxTest/SyntaxChildrenTests.swift b/Tests/SwiftSyntaxTest/SyntaxChildrenTests.swift index 09caf2e8f8c..15976c45172 100644 --- a/Tests/SwiftSyntaxTest/SyntaxChildrenTests.swift +++ b/Tests/SwiftSyntaxTest/SyntaxChildrenTests.swift @@ -71,4 +71,14 @@ public class SyntaxChildrenTests: XCTestCase { try XCTAssertNext(&fixedUpIt) { $0.is(TokenSyntax.self) } try XCTAssertNext(&fixedUpIt) { $0.is(MissingExprSyntax.self) } } + + public func testTokenSequencesWithMissingChild() { + let codeBlock = CodeBlockSyntax( + leftBrace: .leftBraceToken(presence: .missing), + statements: [], + rightBrace: .rightBraceToken(presence: .missing) + ) + + XCTAssertEqual(Array(codeBlock.tokens(viewMode: .all)).count, 2) + } } diff --git a/utils/group.json b/utils/group.json index 8873f1dec56..ba6bb56be3b 100644 --- a/utils/group.json +++ b/utils/group.json @@ -36,6 +36,7 @@ ], "Utils": [ "CommonAncestor.swift", + "MissingNodeInitializers.swift", "SyntaxAnyVisitor.swift", "SyntaxBuilders.swift", "SyntaxClassifier.swift",