SwiftSyntaxGeneratedFiles version 0.4.2

SyntaxFactory.swift

//// Automatically Generated From SyntaxFactory.swift.gyb.
//// Do Not Edit Directly!
//===------- SyntaxFactory.swift - Syntax Factory implementations ---------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the SyntaxFactory, one of the most important client-facing
// types in lib/Syntax and likely to be very commonly used.
//
// Effectively a namespace, SyntaxFactory is never instantiated, but is *the*
// one-stop shop for making new Syntax nodes. Putting all of these into a
// collection of static methods provides a single point of API lookup for
// clients' convenience.
//
//===----------------------------------------------------------------------===//

public enum SyntaxFactory {
  public static func makeToken(_ kind: TokenKind, presence: SourcePresence,
                 leadingTrivia: Trivia = [],
                 trailingTrivia: Trivia = []) -> TokenSyntax {
    let raw = RawSyntax(kind: kind, leadingTrivia: leadingTrivia,
                        trailingTrivia: trailingTrivia, presence: presence)
    let data = SyntaxData(raw: raw)
    return TokenSyntax(root: data, data: data)
  }

  public static func makeUnknownSyntax(tokens: [TokenSyntax]) -> Syntax {
    let raw = RawSyntax(kind: .unknown, layout: tokens.map { $0.data.raw },
                        presence: .present)
    let data = SyntaxData(raw: raw)
    return UnknownSyntax(root: data, data: data)
  }

/// MARK: Syntax Node Creation APIs







  public static func makeBlankUnknownDecl() -> UnknownDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .unknownDecl,
                                         layout: [
    ], presence: .present))
    return UnknownDeclSyntax(root: data, data: data)
  }

  public static func makeBlankUnknownExpr() -> UnknownExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .unknownExpr,
                                         layout: [
    ], presence: .present))
    return UnknownExprSyntax(root: data, data: data)
  }

  public static func makeBlankUnknownStmt() -> UnknownStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .unknownStmt,
                                         layout: [
    ], presence: .present))
    return UnknownStmtSyntax(root: data, data: data)
  }

  public static func makeBlankUnknownType() -> UnknownTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .unknownType,
                                         layout: [
    ], presence: .present))
    return UnknownTypeSyntax(root: data, data: data)
  }

  public static func makeBlankUnknownPattern() -> UnknownPatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .unknownPattern,
                                         layout: [
    ], presence: .present))
    return UnknownPatternSyntax(root: data, data: data)
  }
  public static func makeCodeBlockItem(item: Syntax, semicolon: TokenSyntax?) -> CodeBlockItemSyntax {
    let layout: [RawSyntax?] = [
      item.data.raw,
      semicolon?.data.raw ?? RawSyntax.missingToken(.semicolon),
    ]
    let raw = RawSyntax(kind: SyntaxKind.codeBlockItem,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CodeBlockItemSyntax(root: data, data: data)
  }

  public static func makeBlankCodeBlockItem() -> CodeBlockItemSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .codeBlockItem,
                                         layout: [
      RawSyntax.missing(.unknown),
      RawSyntax.missingToken(.semicolon),
    ], presence: .present))
    return CodeBlockItemSyntax(root: data, data: data)
  }
  public static func makeCodeBlockItemList(
    _ elements: [CodeBlockItemSyntax]) -> CodeBlockItemListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.codeBlockItemList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CodeBlockItemListSyntax(root: data, data: data)
  }

  public static func makeBlankCodeBlockItemList() -> CodeBlockItemListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .codeBlockItemList,
                                         layout: [
    ], presence: .present))
    return CodeBlockItemListSyntax(root: data, data: data)
  }
  public static func makeCodeBlock(leftBrace: TokenSyntax, statements: CodeBlockItemListSyntax, rightBrace: TokenSyntax) -> CodeBlockSyntax {
    let layout: [RawSyntax?] = [
      leftBrace.data.raw,
      statements.data.raw,
      rightBrace.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.codeBlock,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CodeBlockSyntax(root: data, data: data)
  }

  public static func makeBlankCodeBlock() -> CodeBlockSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .codeBlock,
                                         layout: [
      RawSyntax.missingToken(.leftBrace),
      RawSyntax.missing(.codeBlockItemList),
      RawSyntax.missingToken(.rightBrace),
    ], presence: .present))
    return CodeBlockSyntax(root: data, data: data)
  }
  public static func makeInOutExpr(ampersand: TokenSyntax, expression: ExprSyntax) -> InOutExprSyntax {
    let layout: [RawSyntax?] = [
      ampersand.data.raw,
      expression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.inOutExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return InOutExprSyntax(root: data, data: data)
  }

  public static func makeBlankInOutExpr() -> InOutExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .inOutExpr,
                                         layout: [
      RawSyntax.missingToken(.prefixAmpersand),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return InOutExprSyntax(root: data, data: data)
  }
  public static func makePoundColumnExpr(poundColumn: TokenSyntax) -> PoundColumnExprSyntax {
    let layout: [RawSyntax?] = [
      poundColumn.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundColumnExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundColumnExprSyntax(root: data, data: data)
  }

  public static func makeBlankPoundColumnExpr() -> PoundColumnExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundColumnExpr,
                                         layout: [
      RawSyntax.missingToken(.poundColumnKeyword),
    ], presence: .present))
    return PoundColumnExprSyntax(root: data, data: data)
  }
  public static func makeFunctionCallArgumentList(
    _ elements: [FunctionCallArgumentSyntax]) -> FunctionCallArgumentListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.functionCallArgumentList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionCallArgumentListSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionCallArgumentList() -> FunctionCallArgumentListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionCallArgumentList,
                                         layout: [
    ], presence: .present))
    return FunctionCallArgumentListSyntax(root: data, data: data)
  }
  public static func makeTupleElementList(
    _ elements: [TupleElementSyntax]) -> TupleElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.tupleElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TupleElementListSyntax(root: data, data: data)
  }

  public static func makeBlankTupleElementList() -> TupleElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tupleElementList,
                                         layout: [
    ], presence: .present))
    return TupleElementListSyntax(root: data, data: data)
  }
  public static func makeArrayElementList(
    _ elements: [ArrayElementSyntax]) -> ArrayElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.arrayElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ArrayElementListSyntax(root: data, data: data)
  }

  public static func makeBlankArrayElementList() -> ArrayElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .arrayElementList,
                                         layout: [
    ], presence: .present))
    return ArrayElementListSyntax(root: data, data: data)
  }
  public static func makeDictionaryElementList(
    _ elements: [DictionaryElementSyntax]) -> DictionaryElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.dictionaryElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DictionaryElementListSyntax(root: data, data: data)
  }

  public static func makeBlankDictionaryElementList() -> DictionaryElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .dictionaryElementList,
                                         layout: [
    ], presence: .present))
    return DictionaryElementListSyntax(root: data, data: data)
  }
  public static func makeStringInterpolationSegments(
    _ elements: [Syntax]) -> StringInterpolationSegmentsSyntax {
    let raw = RawSyntax(kind: SyntaxKind.stringInterpolationSegments,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return StringInterpolationSegmentsSyntax(root: data, data: data)
  }

  public static func makeBlankStringInterpolationSegments() -> StringInterpolationSegmentsSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .stringInterpolationSegments,
                                         layout: [
    ], presence: .present))
    return StringInterpolationSegmentsSyntax(root: data, data: data)
  }
  public static func makeTryExpr(tryKeyword: TokenSyntax, questionOrExclamationMark: TokenSyntax?, expression: ExprSyntax) -> TryExprSyntax {
    let layout: [RawSyntax?] = [
      tryKeyword.data.raw,
      questionOrExclamationMark?.data.raw ?? RawSyntax.missingToken(.postfixQuestionMark),
      expression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.tryExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TryExprSyntax(root: data, data: data)
  }

  public static func makeBlankTryExpr() -> TryExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tryExpr,
                                         layout: [
      RawSyntax.missingToken(.tryKeyword),
      RawSyntax.missingToken(.postfixQuestionMark),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return TryExprSyntax(root: data, data: data)
  }
  public static func makeDeclNameArgument(name: TokenSyntax, colon: TokenSyntax) -> DeclNameArgumentSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      colon.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.declNameArgument,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeclNameArgumentSyntax(root: data, data: data)
  }

  public static func makeBlankDeclNameArgument() -> DeclNameArgumentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .declNameArgument,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.colon),
    ], presence: .present))
    return DeclNameArgumentSyntax(root: data, data: data)
  }
  public static func makeDeclNameArgumentList(
    _ elements: [DeclNameArgumentSyntax]) -> DeclNameArgumentListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.declNameArgumentList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeclNameArgumentListSyntax(root: data, data: data)
  }

  public static func makeBlankDeclNameArgumentList() -> DeclNameArgumentListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .declNameArgumentList,
                                         layout: [
    ], presence: .present))
    return DeclNameArgumentListSyntax(root: data, data: data)
  }
  public static func makeDeclNameArguments(leftParen: TokenSyntax, arguments: DeclNameArgumentListSyntax, rightParen: TokenSyntax) -> DeclNameArgumentsSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      arguments.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.declNameArguments,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeclNameArgumentsSyntax(root: data, data: data)
  }

  public static func makeBlankDeclNameArguments() -> DeclNameArgumentsSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .declNameArguments,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.declNameArgumentList),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return DeclNameArgumentsSyntax(root: data, data: data)
  }
  public static func makeIdentifierExpr(identifier: TokenSyntax, declNameArguments: DeclNameArgumentsSyntax?) -> IdentifierExprSyntax {
    let layout: [RawSyntax?] = [
      identifier.data.raw,
      declNameArguments?.data.raw ?? RawSyntax.missing(.declNameArguments),
    ]
    let raw = RawSyntax(kind: SyntaxKind.identifierExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IdentifierExprSyntax(root: data, data: data)
  }

  public static func makeBlankIdentifierExpr() -> IdentifierExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .identifierExpr,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.declNameArguments),
    ], presence: .present))
    return IdentifierExprSyntax(root: data, data: data)
  }
  public static func makeSuperRefExpr(superKeyword: TokenSyntax) -> SuperRefExprSyntax {
    let layout: [RawSyntax?] = [
      superKeyword.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.superRefExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SuperRefExprSyntax(root: data, data: data)
  }

  public static func makeBlankSuperRefExpr() -> SuperRefExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .superRefExpr,
                                         layout: [
      RawSyntax.missingToken(.superKeyword),
    ], presence: .present))
    return SuperRefExprSyntax(root: data, data: data)
  }
  public static func makeNilLiteralExpr(nilKeyword: TokenSyntax) -> NilLiteralExprSyntax {
    let layout: [RawSyntax?] = [
      nilKeyword.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.nilLiteralExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return NilLiteralExprSyntax(root: data, data: data)
  }

  public static func makeBlankNilLiteralExpr() -> NilLiteralExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .nilLiteralExpr,
                                         layout: [
      RawSyntax.missingToken(.nilKeyword),
    ], presence: .present))
    return NilLiteralExprSyntax(root: data, data: data)
  }
  public static func makeDiscardAssignmentExpr(wildcard: TokenSyntax) -> DiscardAssignmentExprSyntax {
    let layout: [RawSyntax?] = [
      wildcard.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.discardAssignmentExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DiscardAssignmentExprSyntax(root: data, data: data)
  }

  public static func makeBlankDiscardAssignmentExpr() -> DiscardAssignmentExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .discardAssignmentExpr,
                                         layout: [
      RawSyntax.missingToken(.wildcardKeyword),
    ], presence: .present))
    return DiscardAssignmentExprSyntax(root: data, data: data)
  }
  public static func makeAssignmentExpr(assignToken: TokenSyntax) -> AssignmentExprSyntax {
    let layout: [RawSyntax?] = [
      assignToken.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.assignmentExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AssignmentExprSyntax(root: data, data: data)
  }

  public static func makeBlankAssignmentExpr() -> AssignmentExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .assignmentExpr,
                                         layout: [
      RawSyntax.missingToken(.equal),
    ], presence: .present))
    return AssignmentExprSyntax(root: data, data: data)
  }
  public static func makeSequenceExpr(elements: ExprListSyntax) -> SequenceExprSyntax {
    let layout: [RawSyntax?] = [
      elements.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.sequenceExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SequenceExprSyntax(root: data, data: data)
  }

  public static func makeBlankSequenceExpr() -> SequenceExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .sequenceExpr,
                                         layout: [
      RawSyntax.missing(.exprList),
    ], presence: .present))
    return SequenceExprSyntax(root: data, data: data)
  }
  public static func makeExprList(
    _ elements: [ExprSyntax]) -> ExprListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.exprList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ExprListSyntax(root: data, data: data)
  }

  public static func makeBlankExprList() -> ExprListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .exprList,
                                         layout: [
    ], presence: .present))
    return ExprListSyntax(root: data, data: data)
  }
  public static func makePoundLineExpr(poundLine: TokenSyntax) -> PoundLineExprSyntax {
    let layout: [RawSyntax?] = [
      poundLine.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundLineExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundLineExprSyntax(root: data, data: data)
  }

  public static func makeBlankPoundLineExpr() -> PoundLineExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundLineExpr,
                                         layout: [
      RawSyntax.missingToken(.poundLineKeyword),
    ], presence: .present))
    return PoundLineExprSyntax(root: data, data: data)
  }
  public static func makePoundFileExpr(poundFile: TokenSyntax) -> PoundFileExprSyntax {
    let layout: [RawSyntax?] = [
      poundFile.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundFileExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundFileExprSyntax(root: data, data: data)
  }

  public static func makeBlankPoundFileExpr() -> PoundFileExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundFileExpr,
                                         layout: [
      RawSyntax.missingToken(.poundFileKeyword),
    ], presence: .present))
    return PoundFileExprSyntax(root: data, data: data)
  }
  public static func makePoundFunctionExpr(poundFunction: TokenSyntax) -> PoundFunctionExprSyntax {
    let layout: [RawSyntax?] = [
      poundFunction.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundFunctionExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundFunctionExprSyntax(root: data, data: data)
  }

  public static func makeBlankPoundFunctionExpr() -> PoundFunctionExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundFunctionExpr,
                                         layout: [
      RawSyntax.missingToken(.poundFunctionKeyword),
    ], presence: .present))
    return PoundFunctionExprSyntax(root: data, data: data)
  }
  public static func makePoundDsohandleExpr(poundDsohandle: TokenSyntax) -> PoundDsohandleExprSyntax {
    let layout: [RawSyntax?] = [
      poundDsohandle.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundDsohandleExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundDsohandleExprSyntax(root: data, data: data)
  }

  public static func makeBlankPoundDsohandleExpr() -> PoundDsohandleExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundDsohandleExpr,
                                         layout: [
      RawSyntax.missingToken(.poundDsohandleKeyword),
    ], presence: .present))
    return PoundDsohandleExprSyntax(root: data, data: data)
  }
  public static func makeSymbolicReferenceExpr(identifier: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> SymbolicReferenceExprSyntax {
    let layout: [RawSyntax?] = [
      identifier.data.raw,
      genericArgumentClause?.data.raw ?? RawSyntax.missing(.genericArgumentClause),
    ]
    let raw = RawSyntax(kind: SyntaxKind.symbolicReferenceExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SymbolicReferenceExprSyntax(root: data, data: data)
  }

  public static func makeBlankSymbolicReferenceExpr() -> SymbolicReferenceExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .symbolicReferenceExpr,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericArgumentClause),
    ], presence: .present))
    return SymbolicReferenceExprSyntax(root: data, data: data)
  }
  public static func makePrefixOperatorExpr(operatorToken: TokenSyntax?, postfixExpression: ExprSyntax) -> PrefixOperatorExprSyntax {
    let layout: [RawSyntax?] = [
      operatorToken?.data.raw ?? RawSyntax.missingToken(.prefixOperator("")),
      postfixExpression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.prefixOperatorExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrefixOperatorExprSyntax(root: data, data: data)
  }

  public static func makeBlankPrefixOperatorExpr() -> PrefixOperatorExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .prefixOperatorExpr,
                                         layout: [
      RawSyntax.missingToken(.prefixOperator("")),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return PrefixOperatorExprSyntax(root: data, data: data)
  }
  public static func makeBinaryOperatorExpr(operatorToken: TokenSyntax) -> BinaryOperatorExprSyntax {
    let layout: [RawSyntax?] = [
      operatorToken.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.binaryOperatorExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return BinaryOperatorExprSyntax(root: data, data: data)
  }

  public static func makeBlankBinaryOperatorExpr() -> BinaryOperatorExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .binaryOperatorExpr,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
    ], presence: .present))
    return BinaryOperatorExprSyntax(root: data, data: data)
  }
  public static func makeArrowExpr(throwsToken: TokenSyntax?, arrowToken: TokenSyntax) -> ArrowExprSyntax {
    let layout: [RawSyntax?] = [
      throwsToken?.data.raw ?? RawSyntax.missingToken(.throwsKeyword),
      arrowToken.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.arrowExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ArrowExprSyntax(root: data, data: data)
  }

  public static func makeBlankArrowExpr() -> ArrowExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .arrowExpr,
                                         layout: [
      RawSyntax.missingToken(.throwsKeyword),
      RawSyntax.missingToken(.arrow),
    ], presence: .present))
    return ArrowExprSyntax(root: data, data: data)
  }
  public static func makeFloatLiteralExpr(floatingDigits: TokenSyntax) -> FloatLiteralExprSyntax {
    let layout: [RawSyntax?] = [
      floatingDigits.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.floatLiteralExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FloatLiteralExprSyntax(root: data, data: data)
  }

  public static func makeBlankFloatLiteralExpr() -> FloatLiteralExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .floatLiteralExpr,
                                         layout: [
      RawSyntax.missingToken(.floatingLiteral("")),
    ], presence: .present))
    return FloatLiteralExprSyntax(root: data, data: data)
  }
  public static func makeTupleExpr(leftParen: TokenSyntax, elementList: TupleElementListSyntax, rightParen: TokenSyntax) -> TupleExprSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      elementList.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.tupleExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TupleExprSyntax(root: data, data: data)
  }

  public static func makeBlankTupleExpr() -> TupleExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tupleExpr,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.tupleElementList),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return TupleExprSyntax(root: data, data: data)
  }
  public static func makeArrayExpr(leftSquare: TokenSyntax, elements: ArrayElementListSyntax, rightSquare: TokenSyntax) -> ArrayExprSyntax {
    let layout: [RawSyntax?] = [
      leftSquare.data.raw,
      elements.data.raw,
      rightSquare.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.arrayExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ArrayExprSyntax(root: data, data: data)
  }

  public static func makeBlankArrayExpr() -> ArrayExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .arrayExpr,
                                         layout: [
      RawSyntax.missingToken(.leftSquareBracket),
      RawSyntax.missing(.arrayElementList),
      RawSyntax.missingToken(.rightSquareBracket),
    ], presence: .present))
    return ArrayExprSyntax(root: data, data: data)
  }
  public static func makeDictionaryExpr(leftSquare: TokenSyntax, content: Syntax, rightSquare: TokenSyntax) -> DictionaryExprSyntax {
    let layout: [RawSyntax?] = [
      leftSquare.data.raw,
      content.data.raw,
      rightSquare.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.dictionaryExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DictionaryExprSyntax(root: data, data: data)
  }

  public static func makeBlankDictionaryExpr() -> DictionaryExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .dictionaryExpr,
                                         layout: [
      RawSyntax.missingToken(.leftSquareBracket),
      RawSyntax.missing(.unknown),
      RawSyntax.missingToken(.rightSquareBracket),
    ], presence: .present))
    return DictionaryExprSyntax(root: data, data: data)
  }
  public static func makeImplicitMemberExpr(dot: TokenSyntax, name: TokenSyntax, declNameArguments: DeclNameArgumentsSyntax?) -> ImplicitMemberExprSyntax {
    let layout: [RawSyntax?] = [
      dot.data.raw,
      name.data.raw,
      declNameArguments?.data.raw ?? RawSyntax.missing(.declNameArguments),
    ]
    let raw = RawSyntax(kind: SyntaxKind.implicitMemberExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ImplicitMemberExprSyntax(root: data, data: data)
  }

  public static func makeBlankImplicitMemberExpr() -> ImplicitMemberExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .implicitMemberExpr,
                                         layout: [
      RawSyntax.missingToken(.prefixPeriod),
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missing(.declNameArguments),
    ], presence: .present))
    return ImplicitMemberExprSyntax(root: data, data: data)
  }
  public static func makeFunctionCallArgument(label: TokenSyntax?, colon: TokenSyntax?, expression: ExprSyntax, trailingComma: TokenSyntax?) -> FunctionCallArgumentSyntax {
    let layout: [RawSyntax?] = [
      label?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      colon?.data.raw ?? RawSyntax.missingToken(.colon),
      expression.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.functionCallArgument,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionCallArgumentSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionCallArgument() -> FunctionCallArgumentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionCallArgument,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return FunctionCallArgumentSyntax(root: data, data: data)
  }
  public static func makeTupleElement(label: TokenSyntax?, colon: TokenSyntax?, expression: ExprSyntax, trailingComma: TokenSyntax?) -> TupleElementSyntax {
    let layout: [RawSyntax?] = [
      label?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      colon?.data.raw ?? RawSyntax.missingToken(.colon),
      expression.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.tupleElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TupleElementSyntax(root: data, data: data)
  }

  public static func makeBlankTupleElement() -> TupleElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tupleElement,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return TupleElementSyntax(root: data, data: data)
  }
  public static func makeArrayElement(expression: ExprSyntax, trailingComma: TokenSyntax?) -> ArrayElementSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.arrayElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ArrayElementSyntax(root: data, data: data)
  }

  public static func makeBlankArrayElement() -> ArrayElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .arrayElement,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return ArrayElementSyntax(root: data, data: data)
  }
  public static func makeDictionaryElement(keyExpression: ExprSyntax, colon: TokenSyntax, valueExpression: ExprSyntax, trailingComma: TokenSyntax?) -> DictionaryElementSyntax {
    let layout: [RawSyntax?] = [
      keyExpression.data.raw,
      colon.data.raw,
      valueExpression.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.dictionaryElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DictionaryElementSyntax(root: data, data: data)
  }

  public static func makeBlankDictionaryElement() -> DictionaryElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .dictionaryElement,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return DictionaryElementSyntax(root: data, data: data)
  }
  public static func makeIntegerLiteralExpr(digits: TokenSyntax) -> IntegerLiteralExprSyntax {
    let layout: [RawSyntax?] = [
      digits.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.integerLiteralExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IntegerLiteralExprSyntax(root: data, data: data)
  }

  public static func makeBlankIntegerLiteralExpr() -> IntegerLiteralExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .integerLiteralExpr,
                                         layout: [
      RawSyntax.missingToken(.integerLiteral("")),
    ], presence: .present))
    return IntegerLiteralExprSyntax(root: data, data: data)
  }
  public static func makeStringLiteralExpr(stringLiteral: TokenSyntax) -> StringLiteralExprSyntax {
    let layout: [RawSyntax?] = [
      stringLiteral.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.stringLiteralExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return StringLiteralExprSyntax(root: data, data: data)
  }

  public static func makeBlankStringLiteralExpr() -> StringLiteralExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .stringLiteralExpr,
                                         layout: [
      RawSyntax.missingToken(.stringLiteral("")),
    ], presence: .present))
    return StringLiteralExprSyntax(root: data, data: data)
  }
  public static func makeBooleanLiteralExpr(booleanLiteral: TokenSyntax) -> BooleanLiteralExprSyntax {
    let layout: [RawSyntax?] = [
      booleanLiteral.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.booleanLiteralExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return BooleanLiteralExprSyntax(root: data, data: data)
  }

  public static func makeBlankBooleanLiteralExpr() -> BooleanLiteralExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .booleanLiteralExpr,
                                         layout: [
      RawSyntax.missingToken(.trueKeyword),
    ], presence: .present))
    return BooleanLiteralExprSyntax(root: data, data: data)
  }
  public static func makeTernaryExpr(conditionExpression: ExprSyntax, questionMark: TokenSyntax, firstChoice: ExprSyntax, colonMark: TokenSyntax, secondChoice: ExprSyntax) -> TernaryExprSyntax {
    let layout: [RawSyntax?] = [
      conditionExpression.data.raw,
      questionMark.data.raw,
      firstChoice.data.raw,
      colonMark.data.raw,
      secondChoice.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.ternaryExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TernaryExprSyntax(root: data, data: data)
  }

  public static func makeBlankTernaryExpr() -> TernaryExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .ternaryExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.infixQuestionMark),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return TernaryExprSyntax(root: data, data: data)
  }
  public static func makeMemberAccessExpr(base: ExprSyntax, dot: TokenSyntax, name: TokenSyntax, declNameArguments: DeclNameArgumentsSyntax?) -> MemberAccessExprSyntax {
    let layout: [RawSyntax?] = [
      base.data.raw,
      dot.data.raw,
      name.data.raw,
      declNameArguments?.data.raw ?? RawSyntax.missing(.declNameArguments),
    ]
    let raw = RawSyntax(kind: SyntaxKind.memberAccessExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return MemberAccessExprSyntax(root: data, data: data)
  }

  public static func makeBlankMemberAccessExpr() -> MemberAccessExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .memberAccessExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.period),
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missing(.declNameArguments),
    ], presence: .present))
    return MemberAccessExprSyntax(root: data, data: data)
  }
  public static func makeDotSelfExpr(expression: ExprSyntax, dot: TokenSyntax, selfKeyword: TokenSyntax) -> DotSelfExprSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
      dot.data.raw,
      selfKeyword.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.dotSelfExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DotSelfExprSyntax(root: data, data: data)
  }

  public static func makeBlankDotSelfExpr() -> DotSelfExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .dotSelfExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.period),
      RawSyntax.missingToken(.selfKeyword),
    ], presence: .present))
    return DotSelfExprSyntax(root: data, data: data)
  }
  public static func makeIsExpr(isTok: TokenSyntax, typeName: TypeSyntax) -> IsExprSyntax {
    let layout: [RawSyntax?] = [
      isTok.data.raw,
      typeName.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.isExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IsExprSyntax(root: data, data: data)
  }

  public static func makeBlankIsExpr() -> IsExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .isExpr,
                                         layout: [
      RawSyntax.missingToken(.isKeyword),
      RawSyntax.missing(.type),
    ], presence: .present))
    return IsExprSyntax(root: data, data: data)
  }
  public static func makeAsExpr(asTok: TokenSyntax, questionOrExclamationMark: TokenSyntax?, typeName: TypeSyntax) -> AsExprSyntax {
    let layout: [RawSyntax?] = [
      asTok.data.raw,
      questionOrExclamationMark?.data.raw ?? RawSyntax.missingToken(.postfixQuestionMark),
      typeName.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.asExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AsExprSyntax(root: data, data: data)
  }

  public static func makeBlankAsExpr() -> AsExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .asExpr,
                                         layout: [
      RawSyntax.missingToken(.asKeyword),
      RawSyntax.missingToken(.postfixQuestionMark),
      RawSyntax.missing(.type),
    ], presence: .present))
    return AsExprSyntax(root: data, data: data)
  }
  public static func makeTypeExpr(type: TypeSyntax) -> TypeExprSyntax {
    let layout: [RawSyntax?] = [
      type.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.typeExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TypeExprSyntax(root: data, data: data)
  }

  public static func makeBlankTypeExpr() -> TypeExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .typeExpr,
                                         layout: [
      RawSyntax.missing(.type),
    ], presence: .present))
    return TypeExprSyntax(root: data, data: data)
  }
  public static func makeClosureCaptureItem(specifier: TokenListSyntax?, name: TokenSyntax?, assignToken: TokenSyntax?, expression: ExprSyntax, trailingComma: TokenSyntax?) -> ClosureCaptureItemSyntax {
    let layout: [RawSyntax?] = [
      specifier?.data.raw ?? RawSyntax.missingToken(.unknown("")),
      name?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      assignToken?.data.raw ?? RawSyntax.missingToken(.equal),
      expression.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.closureCaptureItem,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureCaptureItemSyntax(root: data, data: data)
  }

  public static func makeBlankClosureCaptureItem() -> ClosureCaptureItemSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureCaptureItem,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.equal),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return ClosureCaptureItemSyntax(root: data, data: data)
  }
  public static func makeClosureCaptureItemList(
    _ elements: [ClosureCaptureItemSyntax]) -> ClosureCaptureItemListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.closureCaptureItemList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureCaptureItemListSyntax(root: data, data: data)
  }

  public static func makeBlankClosureCaptureItemList() -> ClosureCaptureItemListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureCaptureItemList,
                                         layout: [
    ], presence: .present))
    return ClosureCaptureItemListSyntax(root: data, data: data)
  }
  public static func makeClosureCaptureSignature(leftSquare: TokenSyntax, items: ClosureCaptureItemListSyntax?, rightSquare: TokenSyntax) -> ClosureCaptureSignatureSyntax {
    let layout: [RawSyntax?] = [
      leftSquare.data.raw,
      items?.data.raw ?? RawSyntax.missing(.closureCaptureItemList),
      rightSquare.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.closureCaptureSignature,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureCaptureSignatureSyntax(root: data, data: data)
  }

  public static func makeBlankClosureCaptureSignature() -> ClosureCaptureSignatureSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureCaptureSignature,
                                         layout: [
      RawSyntax.missingToken(.leftSquareBracket),
      RawSyntax.missing(.closureCaptureItemList),
      RawSyntax.missingToken(.rightSquareBracket),
    ], presence: .present))
    return ClosureCaptureSignatureSyntax(root: data, data: data)
  }
  public static func makeClosureParam(name: TokenSyntax, trailingComma: TokenSyntax?) -> ClosureParamSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.closureParam,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureParamSyntax(root: data, data: data)
  }

  public static func makeBlankClosureParam() -> ClosureParamSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureParam,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return ClosureParamSyntax(root: data, data: data)
  }
  public static func makeClosureParamList(
    _ elements: [ClosureParamSyntax]) -> ClosureParamListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.closureParamList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureParamListSyntax(root: data, data: data)
  }

  public static func makeBlankClosureParamList() -> ClosureParamListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureParamList,
                                         layout: [
    ], presence: .present))
    return ClosureParamListSyntax(root: data, data: data)
  }
  public static func makeClosureSignature(capture: ClosureCaptureSignatureSyntax?, input: Syntax?, throwsTok: TokenSyntax?, output: ReturnClauseSyntax?, inTok: TokenSyntax) -> ClosureSignatureSyntax {
    let layout: [RawSyntax?] = [
      capture?.data.raw ?? RawSyntax.missing(.closureCaptureSignature),
      input?.data.raw ?? RawSyntax.missing(.unknown),
      throwsTok?.data.raw ?? RawSyntax.missingToken(.throwsKeyword),
      output?.data.raw ?? RawSyntax.missing(.returnClause),
      inTok.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.closureSignature,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureSignatureSyntax(root: data, data: data)
  }

  public static func makeBlankClosureSignature() -> ClosureSignatureSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureSignature,
                                         layout: [
      RawSyntax.missing(.closureCaptureSignature),
      RawSyntax.missing(.unknown),
      RawSyntax.missingToken(.throwsKeyword),
      RawSyntax.missing(.returnClause),
      RawSyntax.missingToken(.inKeyword),
    ], presence: .present))
    return ClosureSignatureSyntax(root: data, data: data)
  }
  public static func makeClosureExpr(leftBrace: TokenSyntax, signature: ClosureSignatureSyntax?, statements: CodeBlockItemListSyntax, rightBrace: TokenSyntax) -> ClosureExprSyntax {
    let layout: [RawSyntax?] = [
      leftBrace.data.raw,
      signature?.data.raw ?? RawSyntax.missing(.closureSignature),
      statements.data.raw,
      rightBrace.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.closureExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClosureExprSyntax(root: data, data: data)
  }

  public static func makeBlankClosureExpr() -> ClosureExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .closureExpr,
                                         layout: [
      RawSyntax.missingToken(.leftBrace),
      RawSyntax.missing(.closureSignature),
      RawSyntax.missing(.codeBlockItemList),
      RawSyntax.missingToken(.rightBrace),
    ], presence: .present))
    return ClosureExprSyntax(root: data, data: data)
  }
  public static func makeUnresolvedPatternExpr(pattern: PatternSyntax) -> UnresolvedPatternExprSyntax {
    let layout: [RawSyntax?] = [
      pattern.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.unresolvedPatternExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return UnresolvedPatternExprSyntax(root: data, data: data)
  }

  public static func makeBlankUnresolvedPatternExpr() -> UnresolvedPatternExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .unresolvedPatternExpr,
                                         layout: [
      RawSyntax.missing(.pattern),
    ], presence: .present))
    return UnresolvedPatternExprSyntax(root: data, data: data)
  }
  public static func makeFunctionCallExpr(calledExpression: ExprSyntax, leftParen: TokenSyntax?, argumentList: FunctionCallArgumentListSyntax, rightParen: TokenSyntax?, trailingClosure: ClosureExprSyntax?) -> FunctionCallExprSyntax {
    let layout: [RawSyntax?] = [
      calledExpression.data.raw,
      leftParen?.data.raw ?? RawSyntax.missingToken(.leftParen),
      argumentList.data.raw,
      rightParen?.data.raw ?? RawSyntax.missingToken(.rightParen),
      trailingClosure?.data.raw ?? RawSyntax.missing(.closureExpr),
    ]
    let raw = RawSyntax(kind: SyntaxKind.functionCallExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionCallExprSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionCallExpr() -> FunctionCallExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionCallExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.functionCallArgumentList),
      RawSyntax.missingToken(.rightParen),
      RawSyntax.missing(.closureExpr),
    ], presence: .present))
    return FunctionCallExprSyntax(root: data, data: data)
  }
  public static func makeSubscriptExpr(calledExpression: ExprSyntax, leftBracket: TokenSyntax, argumentList: FunctionCallArgumentListSyntax, rightBracket: TokenSyntax, trailingClosure: ClosureExprSyntax?) -> SubscriptExprSyntax {
    let layout: [RawSyntax?] = [
      calledExpression.data.raw,
      leftBracket.data.raw,
      argumentList.data.raw,
      rightBracket.data.raw,
      trailingClosure?.data.raw ?? RawSyntax.missing(.closureExpr),
    ]
    let raw = RawSyntax(kind: SyntaxKind.subscriptExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SubscriptExprSyntax(root: data, data: data)
  }

  public static func makeBlankSubscriptExpr() -> SubscriptExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .subscriptExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.leftSquareBracket),
      RawSyntax.missing(.functionCallArgumentList),
      RawSyntax.missingToken(.rightSquareBracket),
      RawSyntax.missing(.closureExpr),
    ], presence: .present))
    return SubscriptExprSyntax(root: data, data: data)
  }
  public static func makeOptionalChainingExpr(expression: ExprSyntax, questionMark: TokenSyntax) -> OptionalChainingExprSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
      questionMark.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.optionalChainingExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return OptionalChainingExprSyntax(root: data, data: data)
  }

  public static func makeBlankOptionalChainingExpr() -> OptionalChainingExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .optionalChainingExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.postfixQuestionMark),
    ], presence: .present))
    return OptionalChainingExprSyntax(root: data, data: data)
  }
  public static func makeForcedValueExpr(expression: ExprSyntax, exclamationMark: TokenSyntax) -> ForcedValueExprSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
      exclamationMark.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.forcedValueExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ForcedValueExprSyntax(root: data, data: data)
  }

  public static func makeBlankForcedValueExpr() -> ForcedValueExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .forcedValueExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.exclamationMark),
    ], presence: .present))
    return ForcedValueExprSyntax(root: data, data: data)
  }
  public static func makePostfixUnaryExpr(expression: ExprSyntax, operatorToken: TokenSyntax) -> PostfixUnaryExprSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
      operatorToken.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.postfixUnaryExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PostfixUnaryExprSyntax(root: data, data: data)
  }

  public static func makeBlankPostfixUnaryExpr() -> PostfixUnaryExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .postfixUnaryExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.postfixOperator("")),
    ], presence: .present))
    return PostfixUnaryExprSyntax(root: data, data: data)
  }
  public static func makeSpecializeExpr(expression: ExprSyntax, genericArgumentClause: GenericArgumentClauseSyntax) -> SpecializeExprSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
      genericArgumentClause.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.specializeExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SpecializeExprSyntax(root: data, data: data)
  }

  public static func makeBlankSpecializeExpr() -> SpecializeExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .specializeExpr,
                                         layout: [
      RawSyntax.missing(.expr),
      RawSyntax.missing(.genericArgumentClause),
    ], presence: .present))
    return SpecializeExprSyntax(root: data, data: data)
  }
  public static func makeStringSegment(content: TokenSyntax) -> StringSegmentSyntax {
    let layout: [RawSyntax?] = [
      content.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.stringSegment,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return StringSegmentSyntax(root: data, data: data)
  }

  public static func makeBlankStringSegment() -> StringSegmentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .stringSegment,
                                         layout: [
      RawSyntax.missingToken(.stringSegment("")),
    ], presence: .present))
    return StringSegmentSyntax(root: data, data: data)
  }
  public static func makeExpressionSegment(backslash: TokenSyntax, leftParen: TokenSyntax, expression: ExprSyntax, rightParen: TokenSyntax) -> ExpressionSegmentSyntax {
    let layout: [RawSyntax?] = [
      backslash.data.raw,
      leftParen.data.raw,
      expression.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.expressionSegment,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ExpressionSegmentSyntax(root: data, data: data)
  }

  public static func makeBlankExpressionSegment() -> ExpressionSegmentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .expressionSegment,
                                         layout: [
      RawSyntax.missingToken(.backslash),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.stringInterpolationAnchor),
    ], presence: .present))
    return ExpressionSegmentSyntax(root: data, data: data)
  }
  public static func makeStringInterpolationExpr(openQuote: TokenSyntax, segments: StringInterpolationSegmentsSyntax, closeQuote: TokenSyntax) -> StringInterpolationExprSyntax {
    let layout: [RawSyntax?] = [
      openQuote.data.raw,
      segments.data.raw,
      closeQuote.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.stringInterpolationExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return StringInterpolationExprSyntax(root: data, data: data)
  }

  public static func makeBlankStringInterpolationExpr() -> StringInterpolationExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .stringInterpolationExpr,
                                         layout: [
      RawSyntax.missingToken(.stringQuote),
      RawSyntax.missing(.stringInterpolationSegments),
      RawSyntax.missingToken(.stringQuote),
    ], presence: .present))
    return StringInterpolationExprSyntax(root: data, data: data)
  }
  public static func makeKeyPathExpr(backslash: TokenSyntax, expression: ExprSyntax) -> KeyPathExprSyntax {
    let layout: [RawSyntax?] = [
      backslash.data.raw,
      expression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.keyPathExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return KeyPathExprSyntax(root: data, data: data)
  }

  public static func makeBlankKeyPathExpr() -> KeyPathExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .keyPathExpr,
                                         layout: [
      RawSyntax.missingToken(.backslash),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return KeyPathExprSyntax(root: data, data: data)
  }
  public static func makeObjcNamePiece(name: TokenSyntax, dot: TokenSyntax?) -> ObjcNamePieceSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      dot?.data.raw ?? RawSyntax.missingToken(.period),
    ]
    let raw = RawSyntax(kind: SyntaxKind.objcNamePiece,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ObjcNamePieceSyntax(root: data, data: data)
  }

  public static func makeBlankObjcNamePiece() -> ObjcNamePieceSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .objcNamePiece,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.period),
    ], presence: .present))
    return ObjcNamePieceSyntax(root: data, data: data)
  }
  public static func makeObjcName(
    _ elements: [ObjcNamePieceSyntax]) -> ObjcNameSyntax {
    let raw = RawSyntax(kind: SyntaxKind.objcName,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ObjcNameSyntax(root: data, data: data)
  }

  public static func makeBlankObjcName() -> ObjcNameSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .objcName,
                                         layout: [
    ], presence: .present))
    return ObjcNameSyntax(root: data, data: data)
  }
  public static func makeObjcKeyPathExpr(keyPath: TokenSyntax, leftParen: TokenSyntax, name: ObjcNameSyntax, rightParen: TokenSyntax) -> ObjcKeyPathExprSyntax {
    let layout: [RawSyntax?] = [
      keyPath.data.raw,
      leftParen.data.raw,
      name.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.objcKeyPathExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ObjcKeyPathExprSyntax(root: data, data: data)
  }

  public static func makeBlankObjcKeyPathExpr() -> ObjcKeyPathExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .objcKeyPathExpr,
                                         layout: [
      RawSyntax.missingToken(.poundKeyPathKeyword),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.objcName),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return ObjcKeyPathExprSyntax(root: data, data: data)
  }
  public static func makeObjcSelectorExpr(poundSelector: TokenSyntax, leftParen: TokenSyntax, kind: TokenSyntax?, colon: TokenSyntax?, name: ExprSyntax, rightParen: TokenSyntax) -> ObjcSelectorExprSyntax {
    let layout: [RawSyntax?] = [
      poundSelector.data.raw,
      leftParen.data.raw,
      kind?.data.raw ?? RawSyntax.missingToken(.contextualKeyword("")),
      colon?.data.raw ?? RawSyntax.missingToken(.colon),
      name.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.objcSelectorExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ObjcSelectorExprSyntax(root: data, data: data)
  }

  public static func makeBlankObjcSelectorExpr() -> ObjcSelectorExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .objcSelectorExpr,
                                         layout: [
      RawSyntax.missingToken(.poundSelectorKeyword),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missingToken(.contextualKeyword("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return ObjcSelectorExprSyntax(root: data, data: data)
  }
  public static func makeEditorPlaceholderExpr(identifier: TokenSyntax) -> EditorPlaceholderExprSyntax {
    let layout: [RawSyntax?] = [
      identifier.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.editorPlaceholderExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return EditorPlaceholderExprSyntax(root: data, data: data)
  }

  public static func makeBlankEditorPlaceholderExpr() -> EditorPlaceholderExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .editorPlaceholderExpr,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return EditorPlaceholderExprSyntax(root: data, data: data)
  }
  public static func makeObjectLiteralExpr(identifier: TokenSyntax, leftParen: TokenSyntax, arguments: FunctionCallArgumentListSyntax, rightParen: TokenSyntax) -> ObjectLiteralExprSyntax {
    let layout: [RawSyntax?] = [
      identifier.data.raw,
      leftParen.data.raw,
      arguments.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.objectLiteralExpr,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ObjectLiteralExprSyntax(root: data, data: data)
  }

  public static func makeBlankObjectLiteralExpr() -> ObjectLiteralExprSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .objectLiteralExpr,
                                         layout: [
      RawSyntax.missingToken(.poundColorLiteralKeyword),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.functionCallArgumentList),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return ObjectLiteralExprSyntax(root: data, data: data)
  }
  public static func makeTypeInitializerClause(equal: TokenSyntax, value: TypeSyntax) -> TypeInitializerClauseSyntax {
    let layout: [RawSyntax?] = [
      equal.data.raw,
      value.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.typeInitializerClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TypeInitializerClauseSyntax(root: data, data: data)
  }

  public static func makeBlankTypeInitializerClause() -> TypeInitializerClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .typeInitializerClause,
                                         layout: [
      RawSyntax.missingToken(.equal),
      RawSyntax.missing(.type),
    ], presence: .present))
    return TypeInitializerClauseSyntax(root: data, data: data)
  }
  public static func makeTypealiasDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, typealiasKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, initializer: TypeInitializerClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?) -> TypealiasDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      typealiasKeyword.data.raw,
      identifier.data.raw,
      genericParameterClause?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      initializer?.data.raw ?? RawSyntax.missing(.typeInitializerClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
    ]
    let raw = RawSyntax(kind: SyntaxKind.typealiasDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TypealiasDeclSyntax(root: data, data: data)
  }

  public static func makeBlankTypealiasDecl() -> TypealiasDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .typealiasDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.typealiasKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.typeInitializerClause),
      RawSyntax.missing(.genericWhereClause),
    ], presence: .present))
    return TypealiasDeclSyntax(root: data, data: data)
  }
  public static func makeAssociatedtypeDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, associatedtypeKeyword: TokenSyntax, identifier: TokenSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, initializer: TypeInitializerClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?) -> AssociatedtypeDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      associatedtypeKeyword.data.raw,
      identifier.data.raw,
      inheritanceClause?.data.raw ?? RawSyntax.missing(.typeInheritanceClause),
      initializer?.data.raw ?? RawSyntax.missing(.typeInitializerClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
    ]
    let raw = RawSyntax(kind: SyntaxKind.associatedtypeDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AssociatedtypeDeclSyntax(root: data, data: data)
  }

  public static func makeBlankAssociatedtypeDecl() -> AssociatedtypeDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .associatedtypeDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.associatedtypeKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.typeInheritanceClause),
      RawSyntax.missing(.typeInitializerClause),
      RawSyntax.missing(.genericWhereClause),
    ], presence: .present))
    return AssociatedtypeDeclSyntax(root: data, data: data)
  }
  public static func makeFunctionParameterList(
    _ elements: [FunctionParameterSyntax]) -> FunctionParameterListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.functionParameterList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionParameterListSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionParameterList() -> FunctionParameterListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionParameterList,
                                         layout: [
    ], presence: .present))
    return FunctionParameterListSyntax(root: data, data: data)
  }
  public static func makeParameterClause(leftParen: TokenSyntax, parameterList: FunctionParameterListSyntax, rightParen: TokenSyntax) -> ParameterClauseSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      parameterList.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.parameterClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ParameterClauseSyntax(root: data, data: data)
  }

  public static func makeBlankParameterClause() -> ParameterClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .parameterClause,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.functionParameterList),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return ParameterClauseSyntax(root: data, data: data)
  }
  public static func makeReturnClause(arrow: TokenSyntax, returnType: TypeSyntax) -> ReturnClauseSyntax {
    let layout: [RawSyntax?] = [
      arrow.data.raw,
      returnType.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.returnClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ReturnClauseSyntax(root: data, data: data)
  }

  public static func makeBlankReturnClause() -> ReturnClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .returnClause,
                                         layout: [
      RawSyntax.missingToken(.arrow),
      RawSyntax.missing(.type),
    ], presence: .present))
    return ReturnClauseSyntax(root: data, data: data)
  }
  public static func makeFunctionSignature(input: ParameterClauseSyntax, throwsOrRethrowsKeyword: TokenSyntax?, output: ReturnClauseSyntax?) -> FunctionSignatureSyntax {
    let layout: [RawSyntax?] = [
      input.data.raw,
      throwsOrRethrowsKeyword?.data.raw ?? RawSyntax.missingToken(.throwsKeyword),
      output?.data.raw ?? RawSyntax.missing(.returnClause),
    ]
    let raw = RawSyntax(kind: SyntaxKind.functionSignature,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionSignatureSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionSignature() -> FunctionSignatureSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionSignature,
                                         layout: [
      RawSyntax.missing(.parameterClause),
      RawSyntax.missingToken(.throwsKeyword),
      RawSyntax.missing(.returnClause),
    ], presence: .present))
    return FunctionSignatureSyntax(root: data, data: data)
  }
  public static func makeIfConfigClause(poundKeyword: TokenSyntax, condition: ExprSyntax?, elements: Syntax) -> IfConfigClauseSyntax {
    let layout: [RawSyntax?] = [
      poundKeyword.data.raw,
      condition?.data.raw ?? RawSyntax.missing(.expr),
      elements.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.ifConfigClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IfConfigClauseSyntax(root: data, data: data)
  }

  public static func makeBlankIfConfigClause() -> IfConfigClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .ifConfigClause,
                                         layout: [
      RawSyntax.missingToken(.poundIfKeyword),
      RawSyntax.missing(.expr),
      RawSyntax.missing(.unknown),
    ], presence: .present))
    return IfConfigClauseSyntax(root: data, data: data)
  }
  public static func makeIfConfigClauseList(
    _ elements: [IfConfigClauseSyntax]) -> IfConfigClauseListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.ifConfigClauseList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IfConfigClauseListSyntax(root: data, data: data)
  }

  public static func makeBlankIfConfigClauseList() -> IfConfigClauseListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .ifConfigClauseList,
                                         layout: [
    ], presence: .present))
    return IfConfigClauseListSyntax(root: data, data: data)
  }
  public static func makeIfConfigDecl(clauses: IfConfigClauseListSyntax, poundEndif: TokenSyntax) -> IfConfigDeclSyntax {
    let layout: [RawSyntax?] = [
      clauses.data.raw,
      poundEndif.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.ifConfigDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IfConfigDeclSyntax(root: data, data: data)
  }

  public static func makeBlankIfConfigDecl() -> IfConfigDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .ifConfigDecl,
                                         layout: [
      RawSyntax.missing(.ifConfigClauseList),
      RawSyntax.missingToken(.poundEndifKeyword),
    ], presence: .present))
    return IfConfigDeclSyntax(root: data, data: data)
  }
  public static func makePoundErrorDecl(poundError: TokenSyntax, leftParen: TokenSyntax, message: StringLiteralExprSyntax, rightParen: TokenSyntax) -> PoundErrorDeclSyntax {
    let layout: [RawSyntax?] = [
      poundError.data.raw,
      leftParen.data.raw,
      message.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundErrorDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundErrorDeclSyntax(root: data, data: data)
  }

  public static func makeBlankPoundErrorDecl() -> PoundErrorDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundErrorDecl,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.stringLiteralExpr),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return PoundErrorDeclSyntax(root: data, data: data)
  }
  public static func makePoundWarningDecl(poundWarning: TokenSyntax, leftParen: TokenSyntax, message: StringLiteralExprSyntax, rightParen: TokenSyntax) -> PoundWarningDeclSyntax {
    let layout: [RawSyntax?] = [
      poundWarning.data.raw,
      leftParen.data.raw,
      message.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.poundWarningDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PoundWarningDeclSyntax(root: data, data: data)
  }

  public static func makeBlankPoundWarningDecl() -> PoundWarningDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .poundWarningDecl,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.stringLiteralExpr),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return PoundWarningDeclSyntax(root: data, data: data)
  }
  public static func makeDeclModifier(name: TokenSyntax, detail: TokenListSyntax?) -> DeclModifierSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      detail?.data.raw ?? RawSyntax.missingToken(.unknown("")),
    ]
    let raw = RawSyntax(kind: SyntaxKind.declModifier,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeclModifierSyntax(root: data, data: data)
  }

  public static func makeBlankDeclModifier() -> DeclModifierSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .declModifier,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.unknown("")),
    ], presence: .present))
    return DeclModifierSyntax(root: data, data: data)
  }
  public static func makeInheritedType(typeName: TypeSyntax, trailingComma: TokenSyntax?) -> InheritedTypeSyntax {
    let layout: [RawSyntax?] = [
      typeName.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.inheritedType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return InheritedTypeSyntax(root: data, data: data)
  }

  public static func makeBlankInheritedType() -> InheritedTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .inheritedType,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return InheritedTypeSyntax(root: data, data: data)
  }
  public static func makeInheritedTypeList(
    _ elements: [InheritedTypeSyntax]) -> InheritedTypeListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.inheritedTypeList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return InheritedTypeListSyntax(root: data, data: data)
  }

  public static func makeBlankInheritedTypeList() -> InheritedTypeListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .inheritedTypeList,
                                         layout: [
    ], presence: .present))
    return InheritedTypeListSyntax(root: data, data: data)
  }
  public static func makeTypeInheritanceClause(colon: TokenSyntax, inheritedTypeCollection: InheritedTypeListSyntax) -> TypeInheritanceClauseSyntax {
    let layout: [RawSyntax?] = [
      colon.data.raw,
      inheritedTypeCollection.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.typeInheritanceClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TypeInheritanceClauseSyntax(root: data, data: data)
  }

  public static func makeBlankTypeInheritanceClause() -> TypeInheritanceClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .typeInheritanceClause,
                                         layout: [
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.inheritedTypeList),
    ], presence: .present))
    return TypeInheritanceClauseSyntax(root: data, data: data)
  }
  public static func makeClassDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, classKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ClassDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      classKeyword.data.raw,
      identifier.data.raw,
      genericParameterClause?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      inheritanceClause?.data.raw ?? RawSyntax.missing(.typeInheritanceClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      members.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.classDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ClassDeclSyntax(root: data, data: data)
  }

  public static func makeBlankClassDecl() -> ClassDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .classDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.classKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.typeInheritanceClause),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.memberDeclBlock),
    ], presence: .present))
    return ClassDeclSyntax(root: data, data: data)
  }
  public static func makeStructDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, structKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> StructDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      structKeyword.data.raw,
      identifier.data.raw,
      genericParameterClause?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      inheritanceClause?.data.raw ?? RawSyntax.missing(.typeInheritanceClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      members.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.structDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return StructDeclSyntax(root: data, data: data)
  }

  public static func makeBlankStructDecl() -> StructDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .structDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.structKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.typeInheritanceClause),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.memberDeclBlock),
    ], presence: .present))
    return StructDeclSyntax(root: data, data: data)
  }
  public static func makeProtocolDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, protocolKeyword: TokenSyntax, identifier: TokenSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ProtocolDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      protocolKeyword.data.raw,
      identifier.data.raw,
      inheritanceClause?.data.raw ?? RawSyntax.missing(.typeInheritanceClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      members.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.protocolDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ProtocolDeclSyntax(root: data, data: data)
  }

  public static func makeBlankProtocolDecl() -> ProtocolDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .protocolDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.protocolKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.typeInheritanceClause),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.memberDeclBlock),
    ], presence: .present))
    return ProtocolDeclSyntax(root: data, data: data)
  }
  public static func makeExtensionDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, extensionKeyword: TokenSyntax, extendedType: TypeSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ExtensionDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      extensionKeyword.data.raw,
      extendedType.data.raw,
      inheritanceClause?.data.raw ?? RawSyntax.missing(.typeInheritanceClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      members.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.extensionDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ExtensionDeclSyntax(root: data, data: data)
  }

  public static func makeBlankExtensionDecl() -> ExtensionDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .extensionDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.extensionKeyword),
      RawSyntax.missing(.type),
      RawSyntax.missing(.typeInheritanceClause),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.memberDeclBlock),
    ], presence: .present))
    return ExtensionDeclSyntax(root: data, data: data)
  }
  public static func makeMemberDeclBlock(leftBrace: TokenSyntax, members: DeclListSyntax, rightBrace: TokenSyntax) -> MemberDeclBlockSyntax {
    let layout: [RawSyntax?] = [
      leftBrace.data.raw,
      members.data.raw,
      rightBrace.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.memberDeclBlock,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return MemberDeclBlockSyntax(root: data, data: data)
  }

  public static func makeBlankMemberDeclBlock() -> MemberDeclBlockSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .memberDeclBlock,
                                         layout: [
      RawSyntax.missingToken(.leftBrace),
      RawSyntax.missing(.declList),
      RawSyntax.missingToken(.rightBrace),
    ], presence: .present))
    return MemberDeclBlockSyntax(root: data, data: data)
  }
  public static func makeDeclList(
    _ elements: [DeclSyntax]) -> DeclListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.declList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeclListSyntax(root: data, data: data)
  }

  public static func makeBlankDeclList() -> DeclListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .declList,
                                         layout: [
    ], presence: .present))
    return DeclListSyntax(root: data, data: data)
  }
  public static func makeSourceFile(statements: CodeBlockItemListSyntax, eofToken: TokenSyntax) -> SourceFileSyntax {
    let layout: [RawSyntax?] = [
      statements.data.raw,
      eofToken.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.sourceFile,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SourceFileSyntax(root: data, data: data)
  }

  public static func makeBlankSourceFile() -> SourceFileSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .sourceFile,
                                         layout: [
      RawSyntax.missing(.codeBlockItemList),
      RawSyntax.missingToken(.unknown("")),
    ], presence: .present))
    return SourceFileSyntax(root: data, data: data)
  }
  public static func makeInitializerClause(equal: TokenSyntax, value: ExprSyntax) -> InitializerClauseSyntax {
    let layout: [RawSyntax?] = [
      equal.data.raw,
      value.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.initializerClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return InitializerClauseSyntax(root: data, data: data)
  }

  public static func makeBlankInitializerClause() -> InitializerClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .initializerClause,
                                         layout: [
      RawSyntax.missingToken(.equal),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return InitializerClauseSyntax(root: data, data: data)
  }
  public static func makeFunctionParameter(attributes: AttributeListSyntax?, firstName: TokenSyntax?, secondName: TokenSyntax?, colon: TokenSyntax?, type: TypeSyntax?, ellipsis: TokenSyntax?, defaultArgument: InitializerClauseSyntax?, trailingComma: TokenSyntax?) -> FunctionParameterSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      firstName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      secondName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      colon?.data.raw ?? RawSyntax.missingToken(.colon),
      type?.data.raw ?? RawSyntax.missing(.type),
      ellipsis?.data.raw ?? RawSyntax.missingToken(.unknown("")),
      defaultArgument?.data.raw ?? RawSyntax.missing(.initializerClause),
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.functionParameter,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionParameterSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionParameter() -> FunctionParameterSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionParameter,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missing(.initializerClause),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return FunctionParameterSyntax(root: data, data: data)
  }
  public static func makeModifierList(
    _ elements: [DeclModifierSyntax]) -> ModifierListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.modifierList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ModifierListSyntax(root: data, data: data)
  }

  public static func makeBlankModifierList() -> ModifierListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .modifierList,
                                         layout: [
    ], presence: .present))
    return ModifierListSyntax(root: data, data: data)
  }
  public static func makeFunctionDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, funcKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, signature: FunctionSignatureSyntax, genericWhereClause: GenericWhereClauseSyntax?, body: CodeBlockSyntax?) -> FunctionDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      funcKeyword.data.raw,
      identifier.data.raw,
      genericParameterClause?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      signature.data.raw,
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      body?.data.raw ?? RawSyntax.missing(.codeBlock),
    ]
    let raw = RawSyntax(kind: SyntaxKind.functionDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionDeclSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionDecl() -> FunctionDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.funcKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.functionSignature),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return FunctionDeclSyntax(root: data, data: data)
  }
  public static func makeInitializerDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, initKeyword: TokenSyntax, optionalMark: TokenSyntax?, genericParameterClause: GenericParameterClauseSyntax?, parameters: ParameterClauseSyntax, throwsOrRethrowsKeyword: TokenSyntax?, genericWhereClause: GenericWhereClauseSyntax?, body: CodeBlockSyntax?) -> InitializerDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      initKeyword.data.raw,
      optionalMark?.data.raw ?? RawSyntax.missingToken(.postfixQuestionMark),
      genericParameterClause?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      parameters.data.raw,
      throwsOrRethrowsKeyword?.data.raw ?? RawSyntax.missingToken(.throwsKeyword),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      body?.data.raw ?? RawSyntax.missing(.codeBlock),
    ]
    let raw = RawSyntax(kind: SyntaxKind.initializerDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return InitializerDeclSyntax(root: data, data: data)
  }

  public static func makeBlankInitializerDecl() -> InitializerDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .initializerDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.initKeyword),
      RawSyntax.missingToken(.postfixQuestionMark),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.parameterClause),
      RawSyntax.missingToken(.throwsKeyword),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return InitializerDeclSyntax(root: data, data: data)
  }
  public static func makeDeinitializerDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, deinitKeyword: TokenSyntax, body: CodeBlockSyntax) -> DeinitializerDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      deinitKeyword.data.raw,
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.deinitializerDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeinitializerDeclSyntax(root: data, data: data)
  }

  public static func makeBlankDeinitializerDecl() -> DeinitializerDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .deinitializerDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.deinitKeyword),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return DeinitializerDeclSyntax(root: data, data: data)
  }
  public static func makeSubscriptDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, subscriptKeyword: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, indices: ParameterClauseSyntax, result: ReturnClauseSyntax, genericWhereClause: GenericWhereClauseSyntax?, accessor: AccessorBlockSyntax?) -> SubscriptDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      subscriptKeyword.data.raw,
      genericParameterClause?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      indices.data.raw,
      result.data.raw,
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      accessor?.data.raw ?? RawSyntax.missing(.accessorBlock),
    ]
    let raw = RawSyntax(kind: SyntaxKind.subscriptDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SubscriptDeclSyntax(root: data, data: data)
  }

  public static func makeBlankSubscriptDecl() -> SubscriptDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .subscriptDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.subscriptKeyword),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.parameterClause),
      RawSyntax.missing(.returnClause),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.accessorBlock),
    ], presence: .present))
    return SubscriptDeclSyntax(root: data, data: data)
  }
  public static func makeAccessLevelModifier(name: TokenSyntax, leftParen: TokenSyntax?, modifier: TokenSyntax?, rightParen: TokenSyntax?) -> AccessLevelModifierSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      leftParen?.data.raw ?? RawSyntax.missingToken(.leftParen),
      modifier?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      rightParen?.data.raw ?? RawSyntax.missingToken(.rightParen),
    ]
    let raw = RawSyntax(kind: SyntaxKind.accessLevelModifier,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessLevelModifierSyntax(root: data, data: data)
  }

  public static func makeBlankAccessLevelModifier() -> AccessLevelModifierSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessLevelModifier,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return AccessLevelModifierSyntax(root: data, data: data)
  }
  public static func makeAccessPathComponent(name: TokenSyntax, trailingDot: TokenSyntax?) -> AccessPathComponentSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      trailingDot?.data.raw ?? RawSyntax.missingToken(.period),
    ]
    let raw = RawSyntax(kind: SyntaxKind.accessPathComponent,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessPathComponentSyntax(root: data, data: data)
  }

  public static func makeBlankAccessPathComponent() -> AccessPathComponentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessPathComponent,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.period),
    ], presence: .present))
    return AccessPathComponentSyntax(root: data, data: data)
  }
  public static func makeAccessPath(
    _ elements: [AccessPathComponentSyntax]) -> AccessPathSyntax {
    let raw = RawSyntax(kind: SyntaxKind.accessPath,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessPathSyntax(root: data, data: data)
  }

  public static func makeBlankAccessPath() -> AccessPathSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessPath,
                                         layout: [
    ], presence: .present))
    return AccessPathSyntax(root: data, data: data)
  }
  public static func makeImportDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, importTok: TokenSyntax, importKind: TokenSyntax?, path: AccessPathSyntax) -> ImportDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      importTok.data.raw,
      importKind?.data.raw ?? RawSyntax.missingToken(.typealiasKeyword),
      path.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.importDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ImportDeclSyntax(root: data, data: data)
  }

  public static func makeBlankImportDecl() -> ImportDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .importDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.importKeyword),
      RawSyntax.missingToken(.typealiasKeyword),
      RawSyntax.missing(.accessPath),
    ], presence: .present))
    return ImportDeclSyntax(root: data, data: data)
  }
  public static func makeAccessorParameter(leftParen: TokenSyntax, name: TokenSyntax, rightParen: TokenSyntax) -> AccessorParameterSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      name.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.accessorParameter,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessorParameterSyntax(root: data, data: data)
  }

  public static func makeBlankAccessorParameter() -> AccessorParameterSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessorParameter,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return AccessorParameterSyntax(root: data, data: data)
  }
  public static func makeAccessorDecl(attributes: AttributeListSyntax?, modifier: DeclModifierSyntax?, accessorKind: TokenSyntax, parameter: AccessorParameterSyntax?, body: CodeBlockSyntax?) -> AccessorDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifier?.data.raw ?? RawSyntax.missing(.declModifier),
      accessorKind.data.raw,
      parameter?.data.raw ?? RawSyntax.missing(.accessorParameter),
      body?.data.raw ?? RawSyntax.missing(.codeBlock),
    ]
    let raw = RawSyntax(kind: SyntaxKind.accessorDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessorDeclSyntax(root: data, data: data)
  }

  public static func makeBlankAccessorDecl() -> AccessorDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessorDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.declModifier),
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missing(.accessorParameter),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return AccessorDeclSyntax(root: data, data: data)
  }
  public static func makeAccessorList(
    _ elements: [AccessorDeclSyntax]) -> AccessorListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.accessorList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessorListSyntax(root: data, data: data)
  }

  public static func makeBlankAccessorList() -> AccessorListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessorList,
                                         layout: [
    ], presence: .present))
    return AccessorListSyntax(root: data, data: data)
  }
  public static func makeAccessorBlock(leftBrace: TokenSyntax, accessorListOrStmtList: Syntax, rightBrace: TokenSyntax) -> AccessorBlockSyntax {
    let layout: [RawSyntax?] = [
      leftBrace.data.raw,
      accessorListOrStmtList.data.raw,
      rightBrace.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.accessorBlock,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AccessorBlockSyntax(root: data, data: data)
  }

  public static func makeBlankAccessorBlock() -> AccessorBlockSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .accessorBlock,
                                         layout: [
      RawSyntax.missingToken(.leftBrace),
      RawSyntax.missing(.unknown),
      RawSyntax.missingToken(.rightBrace),
    ], presence: .present))
    return AccessorBlockSyntax(root: data, data: data)
  }
  public static func makePatternBinding(pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax?, accessor: AccessorBlockSyntax?, trailingComma: TokenSyntax?) -> PatternBindingSyntax {
    let layout: [RawSyntax?] = [
      pattern.data.raw,
      typeAnnotation?.data.raw ?? RawSyntax.missing(.typeAnnotation),
      initializer?.data.raw ?? RawSyntax.missing(.initializerClause),
      accessor?.data.raw ?? RawSyntax.missing(.accessorBlock),
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.patternBinding,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PatternBindingSyntax(root: data, data: data)
  }

  public static func makeBlankPatternBinding() -> PatternBindingSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .patternBinding,
                                         layout: [
      RawSyntax.missing(.pattern),
      RawSyntax.missing(.typeAnnotation),
      RawSyntax.missing(.initializerClause),
      RawSyntax.missing(.accessorBlock),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return PatternBindingSyntax(root: data, data: data)
  }
  public static func makePatternBindingList(
    _ elements: [PatternBindingSyntax]) -> PatternBindingListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.patternBindingList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PatternBindingListSyntax(root: data, data: data)
  }

  public static func makeBlankPatternBindingList() -> PatternBindingListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .patternBindingList,
                                         layout: [
    ], presence: .present))
    return PatternBindingListSyntax(root: data, data: data)
  }
  public static func makeVariableDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, letOrVarKeyword: TokenSyntax, bindings: PatternBindingListSyntax) -> VariableDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      letOrVarKeyword.data.raw,
      bindings.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.variableDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return VariableDeclSyntax(root: data, data: data)
  }

  public static func makeBlankVariableDecl() -> VariableDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .variableDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.letKeyword),
      RawSyntax.missing(.patternBindingList),
    ], presence: .present))
    return VariableDeclSyntax(root: data, data: data)
  }
  public static func makeEnumCaseElement(identifier: TokenSyntax, associatedValue: ParameterClauseSyntax?, rawValue: InitializerClauseSyntax?, trailingComma: TokenSyntax?) -> EnumCaseElementSyntax {
    let layout: [RawSyntax?] = [
      identifier.data.raw,
      associatedValue?.data.raw ?? RawSyntax.missing(.parameterClause),
      rawValue?.data.raw ?? RawSyntax.missing(.initializerClause),
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.enumCaseElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return EnumCaseElementSyntax(root: data, data: data)
  }

  public static func makeBlankEnumCaseElement() -> EnumCaseElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .enumCaseElement,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.parameterClause),
      RawSyntax.missing(.initializerClause),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return EnumCaseElementSyntax(root: data, data: data)
  }
  public static func makeEnumCaseElementList(
    _ elements: [EnumCaseElementSyntax]) -> EnumCaseElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.enumCaseElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return EnumCaseElementListSyntax(root: data, data: data)
  }

  public static func makeBlankEnumCaseElementList() -> EnumCaseElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .enumCaseElementList,
                                         layout: [
    ], presence: .present))
    return EnumCaseElementListSyntax(root: data, data: data)
  }
  public static func makeEnumCaseDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, caseKeyword: TokenSyntax, elements: EnumCaseElementListSyntax) -> EnumCaseDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      caseKeyword.data.raw,
      elements.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.enumCaseDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return EnumCaseDeclSyntax(root: data, data: data)
  }

  public static func makeBlankEnumCaseDecl() -> EnumCaseDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .enumCaseDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.caseKeyword),
      RawSyntax.missing(.enumCaseElementList),
    ], presence: .present))
    return EnumCaseDeclSyntax(root: data, data: data)
  }
  public static func makeEnumDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, enumKeyword: TokenSyntax, identifier: TokenSyntax, genericParameters: GenericParameterClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> EnumDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      enumKeyword.data.raw,
      identifier.data.raw,
      genericParameters?.data.raw ?? RawSyntax.missing(.genericParameterClause),
      inheritanceClause?.data.raw ?? RawSyntax.missing(.typeInheritanceClause),
      genericWhereClause?.data.raw ?? RawSyntax.missing(.genericWhereClause),
      members.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.enumDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return EnumDeclSyntax(root: data, data: data)
  }

  public static func makeBlankEnumDecl() -> EnumDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .enumDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.enumKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericParameterClause),
      RawSyntax.missing(.typeInheritanceClause),
      RawSyntax.missing(.genericWhereClause),
      RawSyntax.missing(.memberDeclBlock),
    ], presence: .present))
    return EnumDeclSyntax(root: data, data: data)
  }
  public static func makeOperatorDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, operatorKeyword: TokenSyntax, identifier: TokenSyntax, infixOperatorGroup: InfixOperatorGroupSyntax?) -> OperatorDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      operatorKeyword.data.raw,
      identifier.data.raw,
      infixOperatorGroup?.data.raw ?? RawSyntax.missing(.infixOperatorGroup),
    ]
    let raw = RawSyntax(kind: SyntaxKind.operatorDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return OperatorDeclSyntax(root: data, data: data)
  }

  public static func makeBlankOperatorDecl() -> OperatorDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .operatorDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.operatorKeyword),
      RawSyntax.missingToken(.unspacedBinaryOperator("")),
      RawSyntax.missing(.infixOperatorGroup),
    ], presence: .present))
    return OperatorDeclSyntax(root: data, data: data)
  }
  public static func makeInfixOperatorGroup(colon: TokenSyntax, precedenceGroupName: TokenSyntax) -> InfixOperatorGroupSyntax {
    let layout: [RawSyntax?] = [
      colon.data.raw,
      precedenceGroupName.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.infixOperatorGroup,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return InfixOperatorGroupSyntax(root: data, data: data)
  }

  public static func makeBlankInfixOperatorGroup() -> InfixOperatorGroupSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .infixOperatorGroup,
                                         layout: [
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return InfixOperatorGroupSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, precedencegroupKeyword: TokenSyntax, identifier: TokenSyntax, leftBrace: TokenSyntax, groupAttributes: PrecedenceGroupAttributeListSyntax, rightBrace: TokenSyntax) -> PrecedenceGroupDeclSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      modifiers?.data.raw ?? RawSyntax.missing(.modifierList),
      precedencegroupKeyword.data.raw,
      identifier.data.raw,
      leftBrace.data.raw,
      groupAttributes.data.raw,
      rightBrace.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupDecl,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupDeclSyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupDecl() -> PrecedenceGroupDeclSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupDecl,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.modifierList),
      RawSyntax.missingToken(.precedencegroupKeyword),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.leftBrace),
      RawSyntax.missing(.precedenceGroupAttributeList),
      RawSyntax.missingToken(.rightBrace),
    ], presence: .present))
    return PrecedenceGroupDeclSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupAttributeList(
    _ elements: [Syntax]) -> PrecedenceGroupAttributeListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupAttributeList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupAttributeListSyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupAttributeList() -> PrecedenceGroupAttributeListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupAttributeList,
                                         layout: [
    ], presence: .present))
    return PrecedenceGroupAttributeListSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupRelation(higherThanOrLowerThan: TokenSyntax, colon: TokenSyntax, otherNames: PrecedenceGroupNameListSyntax) -> PrecedenceGroupRelationSyntax {
    let layout: [RawSyntax?] = [
      higherThanOrLowerThan.data.raw,
      colon.data.raw,
      otherNames.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupRelation,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupRelationSyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupRelation() -> PrecedenceGroupRelationSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupRelation,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.precedenceGroupNameList),
    ], presence: .present))
    return PrecedenceGroupRelationSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupNameList(
    _ elements: [PrecedenceGroupNameElementSyntax]) -> PrecedenceGroupNameListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupNameList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupNameListSyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupNameList() -> PrecedenceGroupNameListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupNameList,
                                         layout: [
    ], presence: .present))
    return PrecedenceGroupNameListSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupNameElement(name: TokenSyntax, trailingComma: TokenSyntax?) -> PrecedenceGroupNameElementSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupNameElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupNameElementSyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupNameElement() -> PrecedenceGroupNameElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupNameElement,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return PrecedenceGroupNameElementSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupAssignment(assignmentKeyword: TokenSyntax, colon: TokenSyntax, flag: TokenSyntax) -> PrecedenceGroupAssignmentSyntax {
    let layout: [RawSyntax?] = [
      assignmentKeyword.data.raw,
      colon.data.raw,
      flag.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupAssignment,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupAssignmentSyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupAssignment() -> PrecedenceGroupAssignmentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupAssignment,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.trueKeyword),
    ], presence: .present))
    return PrecedenceGroupAssignmentSyntax(root: data, data: data)
  }
  public static func makePrecedenceGroupAssociativity(associativityKeyword: TokenSyntax, colon: TokenSyntax, value: TokenSyntax) -> PrecedenceGroupAssociativitySyntax {
    let layout: [RawSyntax?] = [
      associativityKeyword.data.raw,
      colon.data.raw,
      value.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.precedenceGroupAssociativity,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return PrecedenceGroupAssociativitySyntax(root: data, data: data)
  }

  public static func makeBlankPrecedenceGroupAssociativity() -> PrecedenceGroupAssociativitySyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .precedenceGroupAssociativity,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return PrecedenceGroupAssociativitySyntax(root: data, data: data)
  }
  public static func makeTokenList(
    _ elements: [TokenSyntax]) -> TokenListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.tokenList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TokenListSyntax(root: data, data: data)
  }

  public static func makeBlankTokenList() -> TokenListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tokenList,
                                         layout: [
    ], presence: .present))
    return TokenListSyntax(root: data, data: data)
  }
  public static func makeAttribute(atSignToken: TokenSyntax, attributeName: TokenSyntax, balancedTokens: TokenListSyntax) -> AttributeSyntax {
    let layout: [RawSyntax?] = [
      atSignToken.data.raw,
      attributeName.data.raw,
      balancedTokens.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.attribute,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AttributeSyntax(root: data, data: data)
  }

  public static func makeBlankAttribute() -> AttributeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .attribute,
                                         layout: [
      RawSyntax.missingToken(.atSign),
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.unknown("")),
    ], presence: .present))
    return AttributeSyntax(root: data, data: data)
  }
  public static func makeAttributeList(
    _ elements: [AttributeSyntax]) -> AttributeListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.attributeList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AttributeListSyntax(root: data, data: data)
  }

  public static func makeBlankAttributeList() -> AttributeListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .attributeList,
                                         layout: [
    ], presence: .present))
    return AttributeListSyntax(root: data, data: data)
  }
  public static func makeContinueStmt(continueKeyword: TokenSyntax, label: TokenSyntax?) -> ContinueStmtSyntax {
    let layout: [RawSyntax?] = [
      continueKeyword.data.raw,
      label?.data.raw ?? RawSyntax.missingToken(.identifier("")),
    ]
    let raw = RawSyntax(kind: SyntaxKind.continueStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ContinueStmtSyntax(root: data, data: data)
  }

  public static func makeBlankContinueStmt() -> ContinueStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .continueStmt,
                                         layout: [
      RawSyntax.missingToken(.continueKeyword),
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return ContinueStmtSyntax(root: data, data: data)
  }
  public static func makeWhileStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, whileKeyword: TokenSyntax, conditions: ConditionElementListSyntax, body: CodeBlockSyntax) -> WhileStmtSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      whileKeyword.data.raw,
      conditions.data.raw,
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.whileStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return WhileStmtSyntax(root: data, data: data)
  }

  public static func makeBlankWhileStmt() -> WhileStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .whileStmt,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.whileKeyword),
      RawSyntax.missing(.conditionElementList),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return WhileStmtSyntax(root: data, data: data)
  }
  public static func makeDeferStmt(deferKeyword: TokenSyntax, body: CodeBlockSyntax) -> DeferStmtSyntax {
    let layout: [RawSyntax?] = [
      deferKeyword.data.raw,
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.deferStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeferStmtSyntax(root: data, data: data)
  }

  public static func makeBlankDeferStmt() -> DeferStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .deferStmt,
                                         layout: [
      RawSyntax.missingToken(.deferKeyword),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return DeferStmtSyntax(root: data, data: data)
  }
  public static func makeExpressionStmt(expression: ExprSyntax) -> ExpressionStmtSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.expressionStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ExpressionStmtSyntax(root: data, data: data)
  }

  public static func makeBlankExpressionStmt() -> ExpressionStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .expressionStmt,
                                         layout: [
      RawSyntax.missing(.expr),
    ], presence: .present))
    return ExpressionStmtSyntax(root: data, data: data)
  }
  public static func makeSwitchCaseList(
    _ elements: [Syntax]) -> SwitchCaseListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.switchCaseList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SwitchCaseListSyntax(root: data, data: data)
  }

  public static func makeBlankSwitchCaseList() -> SwitchCaseListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .switchCaseList,
                                         layout: [
    ], presence: .present))
    return SwitchCaseListSyntax(root: data, data: data)
  }
  public static func makeRepeatWhileStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, repeatKeyword: TokenSyntax, body: CodeBlockSyntax, whileKeyword: TokenSyntax, condition: ExprSyntax) -> RepeatWhileStmtSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      repeatKeyword.data.raw,
      body.data.raw,
      whileKeyword.data.raw,
      condition.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.repeatWhileStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return RepeatWhileStmtSyntax(root: data, data: data)
  }

  public static func makeBlankRepeatWhileStmt() -> RepeatWhileStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .repeatWhileStmt,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.repeatKeyword),
      RawSyntax.missing(.codeBlock),
      RawSyntax.missingToken(.whileKeyword),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return RepeatWhileStmtSyntax(root: data, data: data)
  }
  public static func makeGuardStmt(guardKeyword: TokenSyntax, conditions: ConditionElementListSyntax, elseKeyword: TokenSyntax, body: CodeBlockSyntax) -> GuardStmtSyntax {
    let layout: [RawSyntax?] = [
      guardKeyword.data.raw,
      conditions.data.raw,
      elseKeyword.data.raw,
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.guardStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GuardStmtSyntax(root: data, data: data)
  }

  public static func makeBlankGuardStmt() -> GuardStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .guardStmt,
                                         layout: [
      RawSyntax.missingToken(.guardKeyword),
      RawSyntax.missing(.conditionElementList),
      RawSyntax.missingToken(.elseKeyword),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return GuardStmtSyntax(root: data, data: data)
  }
  public static func makeWhereClause(whereKeyword: TokenSyntax, guardResult: ExprSyntax) -> WhereClauseSyntax {
    let layout: [RawSyntax?] = [
      whereKeyword.data.raw,
      guardResult.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.whereClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return WhereClauseSyntax(root: data, data: data)
  }

  public static func makeBlankWhereClause() -> WhereClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .whereClause,
                                         layout: [
      RawSyntax.missingToken(.whereKeyword),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return WhereClauseSyntax(root: data, data: data)
  }
  public static func makeForInStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, forKeyword: TokenSyntax, caseKeyword: TokenSyntax?, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, inKeyword: TokenSyntax, sequenceExpr: ExprSyntax, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> ForInStmtSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      forKeyword.data.raw,
      caseKeyword?.data.raw ?? RawSyntax.missingToken(.caseKeyword),
      pattern.data.raw,
      typeAnnotation?.data.raw ?? RawSyntax.missing(.typeAnnotation),
      inKeyword.data.raw,
      sequenceExpr.data.raw,
      whereClause?.data.raw ?? RawSyntax.missing(.whereClause),
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.forInStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ForInStmtSyntax(root: data, data: data)
  }

  public static func makeBlankForInStmt() -> ForInStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .forInStmt,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.forKeyword),
      RawSyntax.missingToken(.caseKeyword),
      RawSyntax.missing(.pattern),
      RawSyntax.missing(.typeAnnotation),
      RawSyntax.missingToken(.inKeyword),
      RawSyntax.missing(.expr),
      RawSyntax.missing(.whereClause),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return ForInStmtSyntax(root: data, data: data)
  }
  public static func makeSwitchStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, switchKeyword: TokenSyntax, expression: ExprSyntax, leftBrace: TokenSyntax, cases: SwitchCaseListSyntax, rightBrace: TokenSyntax) -> SwitchStmtSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      switchKeyword.data.raw,
      expression.data.raw,
      leftBrace.data.raw,
      cases.data.raw,
      rightBrace.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.switchStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SwitchStmtSyntax(root: data, data: data)
  }

  public static func makeBlankSwitchStmt() -> SwitchStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .switchStmt,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.switchKeyword),
      RawSyntax.missing(.expr),
      RawSyntax.missingToken(.leftBrace),
      RawSyntax.missing(.switchCaseList),
      RawSyntax.missingToken(.rightBrace),
    ], presence: .present))
    return SwitchStmtSyntax(root: data, data: data)
  }
  public static func makeCatchClauseList(
    _ elements: [CatchClauseSyntax]) -> CatchClauseListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.catchClauseList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CatchClauseListSyntax(root: data, data: data)
  }

  public static func makeBlankCatchClauseList() -> CatchClauseListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .catchClauseList,
                                         layout: [
    ], presence: .present))
    return CatchClauseListSyntax(root: data, data: data)
  }
  public static func makeDoStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, doKeyword: TokenSyntax, body: CodeBlockSyntax, catchClauses: CatchClauseListSyntax?) -> DoStmtSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      doKeyword.data.raw,
      body.data.raw,
      catchClauses?.data.raw ?? RawSyntax.missing(.catchClauseList),
    ]
    let raw = RawSyntax(kind: SyntaxKind.doStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DoStmtSyntax(root: data, data: data)
  }

  public static func makeBlankDoStmt() -> DoStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .doStmt,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.doKeyword),
      RawSyntax.missing(.codeBlock),
      RawSyntax.missing(.catchClauseList),
    ], presence: .present))
    return DoStmtSyntax(root: data, data: data)
  }
  public static func makeReturnStmt(returnKeyword: TokenSyntax, expression: ExprSyntax?) -> ReturnStmtSyntax {
    let layout: [RawSyntax?] = [
      returnKeyword.data.raw,
      expression?.data.raw ?? RawSyntax.missing(.expr),
    ]
    let raw = RawSyntax(kind: SyntaxKind.returnStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ReturnStmtSyntax(root: data, data: data)
  }

  public static func makeBlankReturnStmt() -> ReturnStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .returnStmt,
                                         layout: [
      RawSyntax.missingToken(.returnKeyword),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return ReturnStmtSyntax(root: data, data: data)
  }
  public static func makeFallthroughStmt(fallthroughKeyword: TokenSyntax) -> FallthroughStmtSyntax {
    let layout: [RawSyntax?] = [
      fallthroughKeyword.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.fallthroughStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FallthroughStmtSyntax(root: data, data: data)
  }

  public static func makeBlankFallthroughStmt() -> FallthroughStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .fallthroughStmt,
                                         layout: [
      RawSyntax.missingToken(.fallthroughKeyword),
    ], presence: .present))
    return FallthroughStmtSyntax(root: data, data: data)
  }
  public static func makeBreakStmt(breakKeyword: TokenSyntax, label: TokenSyntax?) -> BreakStmtSyntax {
    let layout: [RawSyntax?] = [
      breakKeyword.data.raw,
      label?.data.raw ?? RawSyntax.missingToken(.identifier("")),
    ]
    let raw = RawSyntax(kind: SyntaxKind.breakStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return BreakStmtSyntax(root: data, data: data)
  }

  public static func makeBlankBreakStmt() -> BreakStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .breakStmt,
                                         layout: [
      RawSyntax.missingToken(.breakKeyword),
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return BreakStmtSyntax(root: data, data: data)
  }
  public static func makeCaseItemList(
    _ elements: [CaseItemSyntax]) -> CaseItemListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.caseItemList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CaseItemListSyntax(root: data, data: data)
  }

  public static func makeBlankCaseItemList() -> CaseItemListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .caseItemList,
                                         layout: [
    ], presence: .present))
    return CaseItemListSyntax(root: data, data: data)
  }
  public static func makeConditionElement(condition: Syntax, trailingComma: TokenSyntax?) -> ConditionElementSyntax {
    let layout: [RawSyntax?] = [
      condition.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.conditionElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ConditionElementSyntax(root: data, data: data)
  }

  public static func makeBlankConditionElement() -> ConditionElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .conditionElement,
                                         layout: [
      RawSyntax.missing(.unknown),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return ConditionElementSyntax(root: data, data: data)
  }
  public static func makeAvailabilityCondition(poundAvailableKeyword: TokenSyntax, arguments: TokenListSyntax) -> AvailabilityConditionSyntax {
    let layout: [RawSyntax?] = [
      poundAvailableKeyword.data.raw,
      arguments.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.availabilityCondition,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AvailabilityConditionSyntax(root: data, data: data)
  }

  public static func makeBlankAvailabilityCondition() -> AvailabilityConditionSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .availabilityCondition,
                                         layout: [
      RawSyntax.missingToken(.poundAvailableKeyword),
      RawSyntax.missingToken(.unknown("")),
    ], presence: .present))
    return AvailabilityConditionSyntax(root: data, data: data)
  }
  public static func makeMatchingPatternCondition(caseKeyword: TokenSyntax, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax) -> MatchingPatternConditionSyntax {
    let layout: [RawSyntax?] = [
      caseKeyword.data.raw,
      pattern.data.raw,
      typeAnnotation?.data.raw ?? RawSyntax.missing(.typeAnnotation),
      initializer.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.matchingPatternCondition,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return MatchingPatternConditionSyntax(root: data, data: data)
  }

  public static func makeBlankMatchingPatternCondition() -> MatchingPatternConditionSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .matchingPatternCondition,
                                         layout: [
      RawSyntax.missingToken(.caseKeyword),
      RawSyntax.missing(.pattern),
      RawSyntax.missing(.typeAnnotation),
      RawSyntax.missing(.initializerClause),
    ], presence: .present))
    return MatchingPatternConditionSyntax(root: data, data: data)
  }
  public static func makeOptionalBindingCondition(letOrVarKeyword: TokenSyntax, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax) -> OptionalBindingConditionSyntax {
    let layout: [RawSyntax?] = [
      letOrVarKeyword.data.raw,
      pattern.data.raw,
      typeAnnotation?.data.raw ?? RawSyntax.missing(.typeAnnotation),
      initializer.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.optionalBindingCondition,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return OptionalBindingConditionSyntax(root: data, data: data)
  }

  public static func makeBlankOptionalBindingCondition() -> OptionalBindingConditionSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .optionalBindingCondition,
                                         layout: [
      RawSyntax.missingToken(.letKeyword),
      RawSyntax.missing(.pattern),
      RawSyntax.missing(.typeAnnotation),
      RawSyntax.missing(.initializerClause),
    ], presence: .present))
    return OptionalBindingConditionSyntax(root: data, data: data)
  }
  public static func makeConditionElementList(
    _ elements: [ConditionElementSyntax]) -> ConditionElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.conditionElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ConditionElementListSyntax(root: data, data: data)
  }

  public static func makeBlankConditionElementList() -> ConditionElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .conditionElementList,
                                         layout: [
    ], presence: .present))
    return ConditionElementListSyntax(root: data, data: data)
  }
  public static func makeDeclarationStmt(declaration: DeclSyntax) -> DeclarationStmtSyntax {
    let layout: [RawSyntax?] = [
      declaration.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.declarationStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DeclarationStmtSyntax(root: data, data: data)
  }

  public static func makeBlankDeclarationStmt() -> DeclarationStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .declarationStmt,
                                         layout: [
      RawSyntax.missing(.decl),
    ], presence: .present))
    return DeclarationStmtSyntax(root: data, data: data)
  }
  public static func makeThrowStmt(throwKeyword: TokenSyntax, expression: ExprSyntax) -> ThrowStmtSyntax {
    let layout: [RawSyntax?] = [
      throwKeyword.data.raw,
      expression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.throwStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ThrowStmtSyntax(root: data, data: data)
  }

  public static func makeBlankThrowStmt() -> ThrowStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .throwStmt,
                                         layout: [
      RawSyntax.missingToken(.throwKeyword),
      RawSyntax.missing(.expr),
    ], presence: .present))
    return ThrowStmtSyntax(root: data, data: data)
  }
  public static func makeIfStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, ifKeyword: TokenSyntax, conditions: ConditionElementListSyntax, body: CodeBlockSyntax, elseKeyword: TokenSyntax?, elseBody: Syntax?) -> IfStmtSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      ifKeyword.data.raw,
      conditions.data.raw,
      body.data.raw,
      elseKeyword?.data.raw ?? RawSyntax.missingToken(.elseKeyword),
      elseBody?.data.raw ?? RawSyntax.missing(.unknown),
    ]
    let raw = RawSyntax(kind: SyntaxKind.ifStmt,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IfStmtSyntax(root: data, data: data)
  }

  public static func makeBlankIfStmt() -> IfStmtSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .ifStmt,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missingToken(.ifKeyword),
      RawSyntax.missing(.conditionElementList),
      RawSyntax.missing(.codeBlock),
      RawSyntax.missingToken(.elseKeyword),
      RawSyntax.missing(.unknown),
    ], presence: .present))
    return IfStmtSyntax(root: data, data: data)
  }
  public static func makeElseIfContinuation(ifStatement: IfStmtSyntax) -> ElseIfContinuationSyntax {
    let layout: [RawSyntax?] = [
      ifStatement.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.elseIfContinuation,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ElseIfContinuationSyntax(root: data, data: data)
  }

  public static func makeBlankElseIfContinuation() -> ElseIfContinuationSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .elseIfContinuation,
                                         layout: [
      RawSyntax.missing(.ifStmt),
    ], presence: .present))
    return ElseIfContinuationSyntax(root: data, data: data)
  }
  public static func makeElseBlock(elseKeyword: TokenSyntax, body: CodeBlockSyntax) -> ElseBlockSyntax {
    let layout: [RawSyntax?] = [
      elseKeyword.data.raw,
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.elseBlock,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ElseBlockSyntax(root: data, data: data)
  }

  public static func makeBlankElseBlock() -> ElseBlockSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .elseBlock,
                                         layout: [
      RawSyntax.missingToken(.elseKeyword),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return ElseBlockSyntax(root: data, data: data)
  }
  public static func makeSwitchCase(unknownAttr: AttributeSyntax?, label: Syntax, statements: CodeBlockItemListSyntax) -> SwitchCaseSyntax {
    let layout: [RawSyntax?] = [
      unknownAttr?.data.raw ?? RawSyntax.missing(.attribute),
      label.data.raw,
      statements.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.switchCase,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SwitchCaseSyntax(root: data, data: data)
  }

  public static func makeBlankSwitchCase() -> SwitchCaseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .switchCase,
                                         layout: [
      RawSyntax.missing(.attribute),
      RawSyntax.missing(.unknown),
      RawSyntax.missing(.codeBlockItemList),
    ], presence: .present))
    return SwitchCaseSyntax(root: data, data: data)
  }
  public static func makeSwitchDefaultLabel(defaultKeyword: TokenSyntax, colon: TokenSyntax) -> SwitchDefaultLabelSyntax {
    let layout: [RawSyntax?] = [
      defaultKeyword.data.raw,
      colon.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.switchDefaultLabel,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SwitchDefaultLabelSyntax(root: data, data: data)
  }

  public static func makeBlankSwitchDefaultLabel() -> SwitchDefaultLabelSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .switchDefaultLabel,
                                         layout: [
      RawSyntax.missingToken(.defaultKeyword),
      RawSyntax.missingToken(.colon),
    ], presence: .present))
    return SwitchDefaultLabelSyntax(root: data, data: data)
  }
  public static func makeCaseItem(pattern: PatternSyntax, whereClause: WhereClauseSyntax?, trailingComma: TokenSyntax?) -> CaseItemSyntax {
    let layout: [RawSyntax?] = [
      pattern.data.raw,
      whereClause?.data.raw ?? RawSyntax.missing(.whereClause),
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.caseItem,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CaseItemSyntax(root: data, data: data)
  }

  public static func makeBlankCaseItem() -> CaseItemSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .caseItem,
                                         layout: [
      RawSyntax.missing(.pattern),
      RawSyntax.missing(.whereClause),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return CaseItemSyntax(root: data, data: data)
  }
  public static func makeSwitchCaseLabel(caseKeyword: TokenSyntax, caseItems: CaseItemListSyntax, colon: TokenSyntax) -> SwitchCaseLabelSyntax {
    let layout: [RawSyntax?] = [
      caseKeyword.data.raw,
      caseItems.data.raw,
      colon.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.switchCaseLabel,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SwitchCaseLabelSyntax(root: data, data: data)
  }

  public static func makeBlankSwitchCaseLabel() -> SwitchCaseLabelSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .switchCaseLabel,
                                         layout: [
      RawSyntax.missingToken(.caseKeyword),
      RawSyntax.missing(.caseItemList),
      RawSyntax.missingToken(.colon),
    ], presence: .present))
    return SwitchCaseLabelSyntax(root: data, data: data)
  }
  public static func makeCatchClause(catchKeyword: TokenSyntax, pattern: PatternSyntax?, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> CatchClauseSyntax {
    let layout: [RawSyntax?] = [
      catchKeyword.data.raw,
      pattern?.data.raw ?? RawSyntax.missing(.pattern),
      whereClause?.data.raw ?? RawSyntax.missing(.whereClause),
      body.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.catchClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CatchClauseSyntax(root: data, data: data)
  }

  public static func makeBlankCatchClause() -> CatchClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .catchClause,
                                         layout: [
      RawSyntax.missingToken(.catchKeyword),
      RawSyntax.missing(.pattern),
      RawSyntax.missing(.whereClause),
      RawSyntax.missing(.codeBlock),
    ], presence: .present))
    return CatchClauseSyntax(root: data, data: data)
  }
  public static func makeGenericWhereClause(whereKeyword: TokenSyntax, requirementList: GenericRequirementListSyntax) -> GenericWhereClauseSyntax {
    let layout: [RawSyntax?] = [
      whereKeyword.data.raw,
      requirementList.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.genericWhereClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericWhereClauseSyntax(root: data, data: data)
  }

  public static func makeBlankGenericWhereClause() -> GenericWhereClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericWhereClause,
                                         layout: [
      RawSyntax.missingToken(.whereKeyword),
      RawSyntax.missing(.genericRequirementList),
    ], presence: .present))
    return GenericWhereClauseSyntax(root: data, data: data)
  }
  public static func makeGenericRequirementList(
    _ elements: [Syntax]) -> GenericRequirementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.genericRequirementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericRequirementListSyntax(root: data, data: data)
  }

  public static func makeBlankGenericRequirementList() -> GenericRequirementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericRequirementList,
                                         layout: [
    ], presence: .present))
    return GenericRequirementListSyntax(root: data, data: data)
  }
  public static func makeSameTypeRequirement(leftTypeIdentifier: TypeSyntax, equalityToken: TokenSyntax, rightTypeIdentifier: TypeSyntax, trailingComma: TokenSyntax?) -> SameTypeRequirementSyntax {
    let layout: [RawSyntax?] = [
      leftTypeIdentifier.data.raw,
      equalityToken.data.raw,
      rightTypeIdentifier.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.sameTypeRequirement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SameTypeRequirementSyntax(root: data, data: data)
  }

  public static func makeBlankSameTypeRequirement() -> SameTypeRequirementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .sameTypeRequirement,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.spacedBinaryOperator("")),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return SameTypeRequirementSyntax(root: data, data: data)
  }
  public static func makeGenericParameterList(
    _ elements: [GenericParameterSyntax]) -> GenericParameterListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.genericParameterList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericParameterListSyntax(root: data, data: data)
  }

  public static func makeBlankGenericParameterList() -> GenericParameterListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericParameterList,
                                         layout: [
    ], presence: .present))
    return GenericParameterListSyntax(root: data, data: data)
  }
  public static func makeGenericParameter(attributes: AttributeListSyntax?, name: TokenSyntax, colon: TokenSyntax?, inheritedType: TypeSyntax?, trailingComma: TokenSyntax?) -> GenericParameterSyntax {
    let layout: [RawSyntax?] = [
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      name.data.raw,
      colon?.data.raw ?? RawSyntax.missingToken(.colon),
      inheritedType?.data.raw ?? RawSyntax.missing(.type),
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.genericParameter,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericParameterSyntax(root: data, data: data)
  }

  public static func makeBlankGenericParameter() -> GenericParameterSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericParameter,
                                         layout: [
      RawSyntax.missing(.attributeList),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return GenericParameterSyntax(root: data, data: data)
  }
  public static func makeGenericParameterClause(leftAngleBracket: TokenSyntax, genericParameterList: GenericParameterListSyntax, rightAngleBracket: TokenSyntax) -> GenericParameterClauseSyntax {
    let layout: [RawSyntax?] = [
      leftAngleBracket.data.raw,
      genericParameterList.data.raw,
      rightAngleBracket.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.genericParameterClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericParameterClauseSyntax(root: data, data: data)
  }

  public static func makeBlankGenericParameterClause() -> GenericParameterClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericParameterClause,
                                         layout: [
      RawSyntax.missingToken(.leftAngle),
      RawSyntax.missing(.genericParameterList),
      RawSyntax.missingToken(.rightAngle),
    ], presence: .present))
    return GenericParameterClauseSyntax(root: data, data: data)
  }
  public static func makeConformanceRequirement(leftTypeIdentifier: TypeSyntax, colon: TokenSyntax, rightTypeIdentifier: TypeSyntax, trailingComma: TokenSyntax?) -> ConformanceRequirementSyntax {
    let layout: [RawSyntax?] = [
      leftTypeIdentifier.data.raw,
      colon.data.raw,
      rightTypeIdentifier.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.conformanceRequirement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ConformanceRequirementSyntax(root: data, data: data)
  }

  public static func makeBlankConformanceRequirement() -> ConformanceRequirementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .conformanceRequirement,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return ConformanceRequirementSyntax(root: data, data: data)
  }
  public static func makeSimpleTypeIdentifier(name: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> SimpleTypeIdentifierSyntax {
    let layout: [RawSyntax?] = [
      name.data.raw,
      genericArgumentClause?.data.raw ?? RawSyntax.missing(.genericArgumentClause),
    ]
    let raw = RawSyntax(kind: SyntaxKind.simpleTypeIdentifier,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return SimpleTypeIdentifierSyntax(root: data, data: data)
  }

  public static func makeBlankSimpleTypeIdentifier() -> SimpleTypeIdentifierSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .simpleTypeIdentifier,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericArgumentClause),
    ], presence: .present))
    return SimpleTypeIdentifierSyntax(root: data, data: data)
  }
  public static func makeMemberTypeIdentifier(baseType: TypeSyntax, period: TokenSyntax, name: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> MemberTypeIdentifierSyntax {
    let layout: [RawSyntax?] = [
      baseType.data.raw,
      period.data.raw,
      name.data.raw,
      genericArgumentClause?.data.raw ?? RawSyntax.missing(.genericArgumentClause),
    ]
    let raw = RawSyntax(kind: SyntaxKind.memberTypeIdentifier,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return MemberTypeIdentifierSyntax(root: data, data: data)
  }

  public static func makeBlankMemberTypeIdentifier() -> MemberTypeIdentifierSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .memberTypeIdentifier,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.period),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.genericArgumentClause),
    ], presence: .present))
    return MemberTypeIdentifierSyntax(root: data, data: data)
  }
  public static func makeArrayType(leftSquareBracket: TokenSyntax, elementType: TypeSyntax, rightSquareBracket: TokenSyntax) -> ArrayTypeSyntax {
    let layout: [RawSyntax?] = [
      leftSquareBracket.data.raw,
      elementType.data.raw,
      rightSquareBracket.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.arrayType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ArrayTypeSyntax(root: data, data: data)
  }

  public static func makeBlankArrayType() -> ArrayTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .arrayType,
                                         layout: [
      RawSyntax.missingToken(.leftSquareBracket),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.rightSquareBracket),
    ], presence: .present))
    return ArrayTypeSyntax(root: data, data: data)
  }
  public static func makeDictionaryType(leftSquareBracket: TokenSyntax, keyType: TypeSyntax, colon: TokenSyntax, valueType: TypeSyntax, rightSquareBracket: TokenSyntax) -> DictionaryTypeSyntax {
    let layout: [RawSyntax?] = [
      leftSquareBracket.data.raw,
      keyType.data.raw,
      colon.data.raw,
      valueType.data.raw,
      rightSquareBracket.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.dictionaryType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return DictionaryTypeSyntax(root: data, data: data)
  }

  public static func makeBlankDictionaryType() -> DictionaryTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .dictionaryType,
                                         layout: [
      RawSyntax.missingToken(.leftSquareBracket),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.rightSquareBracket),
    ], presence: .present))
    return DictionaryTypeSyntax(root: data, data: data)
  }
  public static func makeMetatypeType(baseType: TypeSyntax, period: TokenSyntax, typeOrProtocol: TokenSyntax) -> MetatypeTypeSyntax {
    let layout: [RawSyntax?] = [
      baseType.data.raw,
      period.data.raw,
      typeOrProtocol.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.metatypeType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return MetatypeTypeSyntax(root: data, data: data)
  }

  public static func makeBlankMetatypeType() -> MetatypeTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .metatypeType,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.period),
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return MetatypeTypeSyntax(root: data, data: data)
  }
  public static func makeOptionalType(wrappedType: TypeSyntax, questionMark: TokenSyntax) -> OptionalTypeSyntax {
    let layout: [RawSyntax?] = [
      wrappedType.data.raw,
      questionMark.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.optionalType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return OptionalTypeSyntax(root: data, data: data)
  }

  public static func makeBlankOptionalType() -> OptionalTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .optionalType,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.postfixQuestionMark),
    ], presence: .present))
    return OptionalTypeSyntax(root: data, data: data)
  }
  public static func makeImplicitlyUnwrappedOptionalType(wrappedType: TypeSyntax, exclamationMark: TokenSyntax) -> ImplicitlyUnwrappedOptionalTypeSyntax {
    let layout: [RawSyntax?] = [
      wrappedType.data.raw,
      exclamationMark.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.implicitlyUnwrappedOptionalType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ImplicitlyUnwrappedOptionalTypeSyntax(root: data, data: data)
  }

  public static func makeBlankImplicitlyUnwrappedOptionalType() -> ImplicitlyUnwrappedOptionalTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .implicitlyUnwrappedOptionalType,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.exclamationMark),
    ], presence: .present))
    return ImplicitlyUnwrappedOptionalTypeSyntax(root: data, data: data)
  }
  public static func makeCompositionTypeElement(type: TypeSyntax, ampersand: TokenSyntax?) -> CompositionTypeElementSyntax {
    let layout: [RawSyntax?] = [
      type.data.raw,
      ampersand?.data.raw ?? RawSyntax.missingToken(.unknown("")),
    ]
    let raw = RawSyntax(kind: SyntaxKind.compositionTypeElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CompositionTypeElementSyntax(root: data, data: data)
  }

  public static func makeBlankCompositionTypeElement() -> CompositionTypeElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .compositionTypeElement,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.unknown("")),
    ], presence: .present))
    return CompositionTypeElementSyntax(root: data, data: data)
  }
  public static func makeCompositionTypeElementList(
    _ elements: [CompositionTypeElementSyntax]) -> CompositionTypeElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.compositionTypeElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CompositionTypeElementListSyntax(root: data, data: data)
  }

  public static func makeBlankCompositionTypeElementList() -> CompositionTypeElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .compositionTypeElementList,
                                         layout: [
    ], presence: .present))
    return CompositionTypeElementListSyntax(root: data, data: data)
  }
  public static func makeCompositionType(elements: CompositionTypeElementListSyntax) -> CompositionTypeSyntax {
    let layout: [RawSyntax?] = [
      elements.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.compositionType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return CompositionTypeSyntax(root: data, data: data)
  }

  public static func makeBlankCompositionType() -> CompositionTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .compositionType,
                                         layout: [
      RawSyntax.missing(.compositionTypeElementList),
    ], presence: .present))
    return CompositionTypeSyntax(root: data, data: data)
  }
  public static func makeTupleTypeElement(inOut: TokenSyntax?, name: TokenSyntax?, secondName: TokenSyntax?, colon: TokenSyntax?, type: TypeSyntax, ellipsis: TokenSyntax?, initializer: InitializerClauseSyntax?, trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
    let layout: [RawSyntax?] = [
      inOut?.data.raw ?? RawSyntax.missingToken(.unknown("")),
      name?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      secondName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      colon?.data.raw ?? RawSyntax.missingToken(.colon),
      type.data.raw,
      ellipsis?.data.raw ?? RawSyntax.missingToken(.unknown("")),
      initializer?.data.raw ?? RawSyntax.missing(.initializerClause),
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.tupleTypeElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TupleTypeElementSyntax(root: data, data: data)
  }

  public static func makeBlankTupleTypeElement() -> TupleTypeElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tupleTypeElement,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missing(.initializerClause),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return TupleTypeElementSyntax(root: data, data: data)
  }
  public static func makeTupleTypeElementList(
    _ elements: [TupleTypeElementSyntax]) -> TupleTypeElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.tupleTypeElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TupleTypeElementListSyntax(root: data, data: data)
  }

  public static func makeBlankTupleTypeElementList() -> TupleTypeElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tupleTypeElementList,
                                         layout: [
    ], presence: .present))
    return TupleTypeElementListSyntax(root: data, data: data)
  }
  public static func makeTupleType(leftParen: TokenSyntax, elements: TupleTypeElementListSyntax, rightParen: TokenSyntax) -> TupleTypeSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      elements.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.tupleType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TupleTypeSyntax(root: data, data: data)
  }

  public static func makeBlankTupleType() -> TupleTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tupleType,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.tupleTypeElementList),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return TupleTypeSyntax(root: data, data: data)
  }
  public static func makeFunctionType(leftParen: TokenSyntax, arguments: TupleTypeElementListSyntax, rightParen: TokenSyntax, throwsOrRethrowsKeyword: TokenSyntax?, arrow: TokenSyntax, returnType: TypeSyntax) -> FunctionTypeSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      arguments.data.raw,
      rightParen.data.raw,
      throwsOrRethrowsKeyword?.data.raw ?? RawSyntax.missingToken(.throwsKeyword),
      arrow.data.raw,
      returnType.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.functionType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return FunctionTypeSyntax(root: data, data: data)
  }

  public static func makeBlankFunctionType() -> FunctionTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .functionType,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.tupleTypeElementList),
      RawSyntax.missingToken(.rightParen),
      RawSyntax.missingToken(.throwsKeyword),
      RawSyntax.missingToken(.arrow),
      RawSyntax.missing(.type),
    ], presence: .present))
    return FunctionTypeSyntax(root: data, data: data)
  }
  public static func makeAttributedType(specifier: TokenSyntax?, attributes: AttributeListSyntax?, baseType: TypeSyntax) -> AttributedTypeSyntax {
    let layout: [RawSyntax?] = [
      specifier?.data.raw ?? RawSyntax.missingToken(.unknown("")),
      attributes?.data.raw ?? RawSyntax.missing(.attributeList),
      baseType.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.attributedType,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AttributedTypeSyntax(root: data, data: data)
  }

  public static func makeBlankAttributedType() -> AttributedTypeSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .attributedType,
                                         layout: [
      RawSyntax.missingToken(.unknown("")),
      RawSyntax.missing(.attributeList),
      RawSyntax.missing(.type),
    ], presence: .present))
    return AttributedTypeSyntax(root: data, data: data)
  }
  public static func makeGenericArgumentList(
    _ elements: [GenericArgumentSyntax]) -> GenericArgumentListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.genericArgumentList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericArgumentListSyntax(root: data, data: data)
  }

  public static func makeBlankGenericArgumentList() -> GenericArgumentListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericArgumentList,
                                         layout: [
    ], presence: .present))
    return GenericArgumentListSyntax(root: data, data: data)
  }
  public static func makeGenericArgument(argumentType: TypeSyntax, trailingComma: TokenSyntax?) -> GenericArgumentSyntax {
    let layout: [RawSyntax?] = [
      argumentType.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.genericArgument,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericArgumentSyntax(root: data, data: data)
  }

  public static func makeBlankGenericArgument() -> GenericArgumentSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericArgument,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return GenericArgumentSyntax(root: data, data: data)
  }
  public static func makeGenericArgumentClause(leftAngleBracket: TokenSyntax, arguments: GenericArgumentListSyntax, rightAngleBracket: TokenSyntax) -> GenericArgumentClauseSyntax {
    let layout: [RawSyntax?] = [
      leftAngleBracket.data.raw,
      arguments.data.raw,
      rightAngleBracket.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.genericArgumentClause,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return GenericArgumentClauseSyntax(root: data, data: data)
  }

  public static func makeBlankGenericArgumentClause() -> GenericArgumentClauseSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .genericArgumentClause,
                                         layout: [
      RawSyntax.missingToken(.leftAngle),
      RawSyntax.missing(.genericArgumentList),
      RawSyntax.missingToken(.rightAngle),
    ], presence: .present))
    return GenericArgumentClauseSyntax(root: data, data: data)
  }
  public static func makeTypeAnnotation(colon: TokenSyntax, type: TypeSyntax) -> TypeAnnotationSyntax {
    let layout: [RawSyntax?] = [
      colon.data.raw,
      type.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.typeAnnotation,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TypeAnnotationSyntax(root: data, data: data)
  }

  public static func makeBlankTypeAnnotation() -> TypeAnnotationSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .typeAnnotation,
                                         layout: [
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.type),
    ], presence: .present))
    return TypeAnnotationSyntax(root: data, data: data)
  }
  public static func makeEnumCasePattern(type: TypeSyntax?, period: TokenSyntax, caseName: TokenSyntax, associatedTuple: TuplePatternSyntax?) -> EnumCasePatternSyntax {
    let layout: [RawSyntax?] = [
      type?.data.raw ?? RawSyntax.missing(.type),
      period.data.raw,
      caseName.data.raw,
      associatedTuple?.data.raw ?? RawSyntax.missing(.tuplePattern),
    ]
    let raw = RawSyntax(kind: SyntaxKind.enumCasePattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return EnumCasePatternSyntax(root: data, data: data)
  }

  public static func makeBlankEnumCasePattern() -> EnumCasePatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .enumCasePattern,
                                         layout: [
      RawSyntax.missing(.type),
      RawSyntax.missingToken(.period),
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missing(.tuplePattern),
    ], presence: .present))
    return EnumCasePatternSyntax(root: data, data: data)
  }
  public static func makeIsTypePattern(isKeyword: TokenSyntax, type: TypeSyntax) -> IsTypePatternSyntax {
    let layout: [RawSyntax?] = [
      isKeyword.data.raw,
      type.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.isTypePattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IsTypePatternSyntax(root: data, data: data)
  }

  public static func makeBlankIsTypePattern() -> IsTypePatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .isTypePattern,
                                         layout: [
      RawSyntax.missingToken(.isKeyword),
      RawSyntax.missing(.type),
    ], presence: .present))
    return IsTypePatternSyntax(root: data, data: data)
  }
  public static func makeOptionalPattern(subPattern: PatternSyntax, questionMark: TokenSyntax) -> OptionalPatternSyntax {
    let layout: [RawSyntax?] = [
      subPattern.data.raw,
      questionMark.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.optionalPattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return OptionalPatternSyntax(root: data, data: data)
  }

  public static func makeBlankOptionalPattern() -> OptionalPatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .optionalPattern,
                                         layout: [
      RawSyntax.missing(.pattern),
      RawSyntax.missingToken(.postfixQuestionMark),
    ], presence: .present))
    return OptionalPatternSyntax(root: data, data: data)
  }
  public static func makeIdentifierPattern(identifier: TokenSyntax) -> IdentifierPatternSyntax {
    let layout: [RawSyntax?] = [
      identifier.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.identifierPattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return IdentifierPatternSyntax(root: data, data: data)
  }

  public static func makeBlankIdentifierPattern() -> IdentifierPatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .identifierPattern,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
    ], presence: .present))
    return IdentifierPatternSyntax(root: data, data: data)
  }
  public static func makeAsTypePattern(pattern: PatternSyntax, asKeyword: TokenSyntax, type: TypeSyntax) -> AsTypePatternSyntax {
    let layout: [RawSyntax?] = [
      pattern.data.raw,
      asKeyword.data.raw,
      type.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.asTypePattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return AsTypePatternSyntax(root: data, data: data)
  }

  public static func makeBlankAsTypePattern() -> AsTypePatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .asTypePattern,
                                         layout: [
      RawSyntax.missing(.pattern),
      RawSyntax.missingToken(.asKeyword),
      RawSyntax.missing(.type),
    ], presence: .present))
    return AsTypePatternSyntax(root: data, data: data)
  }
  public static func makeTuplePattern(leftParen: TokenSyntax, elements: TuplePatternElementListSyntax, rightParen: TokenSyntax) -> TuplePatternSyntax {
    let layout: [RawSyntax?] = [
      leftParen.data.raw,
      elements.data.raw,
      rightParen.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.tuplePattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TuplePatternSyntax(root: data, data: data)
  }

  public static func makeBlankTuplePattern() -> TuplePatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tuplePattern,
                                         layout: [
      RawSyntax.missingToken(.leftParen),
      RawSyntax.missing(.tuplePatternElementList),
      RawSyntax.missingToken(.rightParen),
    ], presence: .present))
    return TuplePatternSyntax(root: data, data: data)
  }
  public static func makeWildcardPattern(wildcard: TokenSyntax, typeAnnotation: TypeAnnotationSyntax?) -> WildcardPatternSyntax {
    let layout: [RawSyntax?] = [
      wildcard.data.raw,
      typeAnnotation?.data.raw ?? RawSyntax.missing(.typeAnnotation),
    ]
    let raw = RawSyntax(kind: SyntaxKind.wildcardPattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return WildcardPatternSyntax(root: data, data: data)
  }

  public static func makeBlankWildcardPattern() -> WildcardPatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .wildcardPattern,
                                         layout: [
      RawSyntax.missingToken(.wildcardKeyword),
      RawSyntax.missing(.typeAnnotation),
    ], presence: .present))
    return WildcardPatternSyntax(root: data, data: data)
  }
  public static func makeTuplePatternElement(labelName: TokenSyntax?, labelColon: TokenSyntax?, pattern: PatternSyntax, trailingComma: TokenSyntax?) -> TuplePatternElementSyntax {
    let layout: [RawSyntax?] = [
      labelName?.data.raw ?? RawSyntax.missingToken(.identifier("")),
      labelColon?.data.raw ?? RawSyntax.missingToken(.colon),
      pattern.data.raw,
      trailingComma?.data.raw ?? RawSyntax.missingToken(.comma),
    ]
    let raw = RawSyntax(kind: SyntaxKind.tuplePatternElement,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TuplePatternElementSyntax(root: data, data: data)
  }

  public static func makeBlankTuplePatternElement() -> TuplePatternElementSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tuplePatternElement,
                                         layout: [
      RawSyntax.missingToken(.identifier("")),
      RawSyntax.missingToken(.colon),
      RawSyntax.missing(.pattern),
      RawSyntax.missingToken(.comma),
    ], presence: .present))
    return TuplePatternElementSyntax(root: data, data: data)
  }
  public static func makeExpressionPattern(expression: ExprSyntax) -> ExpressionPatternSyntax {
    let layout: [RawSyntax?] = [
      expression.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.expressionPattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ExpressionPatternSyntax(root: data, data: data)
  }

  public static func makeBlankExpressionPattern() -> ExpressionPatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .expressionPattern,
                                         layout: [
      RawSyntax.missing(.expr),
    ], presence: .present))
    return ExpressionPatternSyntax(root: data, data: data)
  }
  public static func makeTuplePatternElementList(
    _ elements: [TuplePatternElementSyntax]) -> TuplePatternElementListSyntax {
    let raw = RawSyntax(kind: SyntaxKind.tuplePatternElementList,
                        layout: elements.map { $0.data.raw },
                        presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return TuplePatternElementListSyntax(root: data, data: data)
  }

  public static func makeBlankTuplePatternElementList() -> TuplePatternElementListSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .tuplePatternElementList,
                                         layout: [
    ], presence: .present))
    return TuplePatternElementListSyntax(root: data, data: data)
  }
  public static func makeValueBindingPattern(letOrVarKeyword: TokenSyntax, valuePattern: PatternSyntax) -> ValueBindingPatternSyntax {
    let layout: [RawSyntax?] = [
      letOrVarKeyword.data.raw,
      valuePattern.data.raw,
    ]
    let raw = RawSyntax(kind: SyntaxKind.valueBindingPattern,
                        layout: layout, presence: SourcePresence.present)
    let data = SyntaxData(raw: raw)
    return ValueBindingPatternSyntax(root: data, data: data)
  }

  public static func makeBlankValueBindingPattern() -> ValueBindingPatternSyntax {
    let data = SyntaxData(raw: RawSyntax(kind: .valueBindingPattern,
                                         layout: [
      RawSyntax.missingToken(.letKeyword),
      RawSyntax.missing(.pattern),
    ], presence: .present))
    return ValueBindingPatternSyntax(root: data, data: data)
  }

/// MARK: Token Creation APIs

  public static func makeAssociatedtypeKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.associatedtypeKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeClassKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.classKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeDeinitKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.deinitKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeEnumKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.enumKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeExtensionKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.extensionKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeFuncKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.funcKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeImportKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.importKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeInitKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.initKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeInoutKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.inoutKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeLetKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.letKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeOperatorKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.operatorKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePrecedencegroupKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.precedencegroupKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeProtocolKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.protocolKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeStructKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.structKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeSubscriptKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.subscriptKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeTypealiasKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.typealiasKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeVarKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.varKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeFileprivateKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.fileprivateKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeInternalKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.internalKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePrivateKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.privateKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePublicKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.publicKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeStaticKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.staticKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeDeferKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.deferKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeIfKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.ifKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeGuardKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.guardKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeDoKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.doKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeRepeatKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.repeatKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeElseKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.elseKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeForKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.forKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeInKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.inKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeWhileKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.whileKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeReturnKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.returnKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeBreakKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.breakKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeContinueKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.continueKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeFallthroughKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.fallthroughKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeSwitchKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.switchKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeCaseKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.caseKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeDefaultKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.defaultKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeWhereKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.whereKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeCatchKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.catchKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeAsKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.asKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeAnyKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.anyKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeFalseKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.falseKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeIsKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.isKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeNilKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.nilKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeRethrowsKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.rethrowsKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeSuperKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.superKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeSelfKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.selfKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeCapitalSelfKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.capitalSelfKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeThrowKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.throwKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeTrueKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.trueKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeTryKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.tryKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeThrowsKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.throwsKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func make__FILE__Keyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.__file__Keyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func make__LINE__Keyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.__line__Keyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func make__COLUMN__Keyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.__column__Keyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func make__FUNCTION__Keyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.__function__Keyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func make__DSO_HANDLE__Keyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.__dso_handle__Keyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeWildcardKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.wildcardKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundAvailableKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundAvailableKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundEndifKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundEndifKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundElseKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundElseKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundElseifKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundElseifKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundIfKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundIfKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundSourceLocationKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundSourceLocationKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundFileKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundFileKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundLineKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundLineKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundColumnKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundColumnKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundDsohandleKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundDsohandleKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundFunctionKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundFunctionKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundSelectorKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundSelectorKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundKeyPathKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundKeyPathKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundColorLiteralKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundColorLiteralKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundFileLiteralKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundFileLiteralKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePoundImageLiteralKeyword(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.poundImageLiteralKeyword, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeArrowToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.arrow, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeAtSignToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.atSign, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeColonToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.colon, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeSemicolonToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.semicolon, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeCommaToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.comma, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePeriodToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.period, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeEqualToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.equal, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePrefixPeriodToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.prefixPeriod, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeLeftParenToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.leftParen, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeRightParenToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.rightParen, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeLeftBraceToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.leftBrace, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeRightBraceToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.rightBrace, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeLeftSquareBracketToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.leftSquareBracket, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeRightSquareBracketToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.rightSquareBracket, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeLeftAngleToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.leftAngle, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeRightAngleToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.rightAngle, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePrefixAmpersandToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.prefixAmpersand, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePostfixQuestionMarkToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.postfixQuestionMark, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeInfixQuestionMarkToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.infixQuestionMark, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeExclamationMarkToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.exclamationMark, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeBackslashToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.backslash, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeStringInterpolationAnchorToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.stringInterpolationAnchor, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeStringQuoteToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.stringQuote, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeMultilineStringQuoteToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.multilineStringQuote, presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeStringSegment(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.stringSegment(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeIdentifier(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.identifier(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeDollarIdentifier(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.dollarIdentifier(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeUnspacedBinaryOperator(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.unspacedBinaryOperator(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeSpacedBinaryOperator(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.spacedBinaryOperator(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePrefixOperator(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.prefixOperator(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makePostfixOperator(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.postfixOperator(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeIntegerLiteral(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.integerLiteral(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeFloatingLiteral(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.floatingLiteral(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeStringLiteral(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.stringLiteral(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeContextualKeyword(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.contextualKeyword(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }
  public static func makeUnknown(_ text: String,
    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.unknown(text), presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }

/// MARK: Convenience APIs

  public static func makeVoidTupleType() -> TupleTypeSyntax {
    return makeTupleType(leftParen: makeLeftParenToken(),
                         elements: makeBlankTupleTypeElementList(),
                         rightParen: makeRightParenToken())
  }

  public static func makeTupleTypeElement(name: TokenSyntax?,
    colon: TokenSyntax?, type: TypeSyntax,
    trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
    return makeTupleTypeElement(inOut: nil, name: name, secondName: nil,
                                colon: colon, type: type, ellipsis: nil,
                                initializer: nil, trailingComma: trailingComma)
  }

  public static func makeTupleTypeElement(type: TypeSyntax,
    trailingComma: TokenSyntax?) -> TupleTypeElementSyntax  {
    return makeTupleTypeElement(name: nil, colon: nil, 
                                type: type, trailingComma: trailingComma)
  }

  public static func makeGenericParameter(name: TokenSyntax,
      trailingComma: TokenSyntax) -> GenericParameterSyntax {
    return makeGenericParameter(attributes: nil, name: name, colon: nil,
                                inheritedType: nil,
                                trailingComma: trailingComma)
  }

  public static func makeTypeIdentifier(_ name: String,
    leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TypeSyntax {
    let identifier = makeIdentifier(name, leadingTrivia: leadingTrivia, 
                                    trailingTrivia: trailingTrivia)
    return makeSimpleTypeIdentifier(name: identifier,
                                    genericArgumentClause: nil)
  }

  public static func makeAnyTypeIdentifier(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TypeSyntax {
    return makeTypeIdentifier("Any", leadingTrivia: leadingTrivia, 
                              trailingTrivia: trailingTrivia)
  }

  public static func makeSelfTypeIdentifier(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TypeSyntax {
    return makeTypeIdentifier("Self", leadingTrivia: leadingTrivia, 
                              trailingTrivia: trailingTrivia)
  }

  public static func makeTypeToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeIdentifier("Type", leadingTrivia: leadingTrivia, 
                          trailingTrivia: trailingTrivia)
  }

  public static func makeProtocolToken(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeIdentifier("Protocol", leadingTrivia: leadingTrivia,
                          trailingTrivia: trailingTrivia)
  }

  public static func makeEqualityOperator(leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> TokenSyntax {
    return makeToken(.spacedBinaryOperator("=="),
                     presence: .present,
                     leadingTrivia: leadingTrivia,
                     trailingTrivia: trailingTrivia)
  }

  public static func makeStringLiteralExpr(_ text: String,
    leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> StringLiteralExprSyntax {
    let literal = makeStringLiteral("\"\(text)\"", 
                                    leadingTrivia: leadingTrivia,
                                    trailingTrivia: trailingTrivia)
    return makeStringLiteralExpr(stringLiteral: literal)
  }

  public static func makeVariableExpr(_ text: String,
    leadingTrivia: Trivia = [],
    trailingTrivia: Trivia = []) -> IdentifierExprSyntax {
    let string = makeIdentifier(text,
      leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia)
    return makeIdentifierExpr(identifier: string,
                              declNameArguments: nil)
  }
}

SyntaxNodes-FunctionParameter.swift

public struct FunctionParameterSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case firstName
    case secondName
    case colon
    case type
    case ellipsis
    case defaultArgument
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionParameterSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> FunctionParameterSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return FunctionParameterSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var firstName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.firstName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `firstName` replaced.
  /// - param newChild: The new `firstName` to replace the node's
  ///                   current `firstName`, if present.
  public func withFirstName(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.firstName)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var secondName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.secondName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `secondName` replaced.
  /// - param newChild: The new `secondName` to replace the node's
  ///                   current `secondName`, if present.
  public func withSecondName(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.secondName)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var type: TypeSyntax? {
    let child = data.cachedChild(at: Cursor.type)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var ellipsis: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.ellipsis)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `ellipsis` replaced.
  /// - param newChild: The new `ellipsis` to replace the node's
  ///                   current `ellipsis`, if present.
  public func withEllipsis(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ellipsis)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var defaultArgument: InitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.defaultArgument)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `defaultArgument` replaced.
  /// - param newChild: The new `defaultArgument` to replace the node's
  ///                   current `defaultArgument`, if present.
  public func withDefaultArgument(
    _ newChild: InitializerClauseSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.defaultArgument)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return FunctionParameterSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionParameterSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionParameterSyntax, rhs: FunctionParameterSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}

SyntaxNodes.swift

//// Automatically Generated From SyntaxNodes.swift.gyb.
//// Do Not Edit Directly!
//===------------ SyntaxNodes.swift - Syntax Node definitions -------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 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
//
//===----------------------------------------------------------------------===//


/// A wrapper around a raw Syntax layout.
public struct UnknownSyntax: _SyntaxBase {
  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates an `UnknownSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }
}

public protocol DeclSyntax: Syntax {}

public protocol ExprSyntax: Syntax {}

public protocol StmtSyntax: Syntax {}

public protocol TypeSyntax: Syntax {}

public protocol PatternSyntax: Syntax {}


public struct UnknownDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `UnknownDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }


  /// Determines if two `UnknownDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: UnknownDeclSyntax, rhs: UnknownDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct UnknownExprSyntax: ExprSyntax, _SyntaxBase, Hashable {

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `UnknownExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }


  /// Determines if two `UnknownExprSyntax` nodes are equal to each other.
  public static func ==(lhs: UnknownExprSyntax, rhs: UnknownExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct UnknownStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `UnknownStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }


  /// Determines if two `UnknownStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: UnknownStmtSyntax, rhs: UnknownStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct UnknownTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `UnknownTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }


  /// Determines if two `UnknownTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: UnknownTypeSyntax, rhs: UnknownTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct UnknownPatternSyntax: PatternSyntax, _SyntaxBase, Hashable {

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `UnknownPatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }


  /// Determines if two `UnknownPatternSyntax` nodes are equal to each other.
  public static func ==(lhs: UnknownPatternSyntax, rhs: UnknownPatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// A CodeBlockItem is any Syntax node that appears on its own line inside
/// a CodeBlock.
/// 
public struct CodeBlockItemSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case item
    case semicolon
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `CodeBlockItemSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// The underlying node inside the code block.
  public var item: Syntax {
    let child = data.cachedChild(at: Cursor.item)
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `item` replaced.
  /// - param newChild: The new `item` to replace the node's
  ///                   current `item`, if present.
  public func withItem(
    _ newChild: Syntax?) -> CodeBlockItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.item)
    return CodeBlockItemSyntax(root: root, data: newData)
  }
  /// 
  /// If present, the trailing semicolon at the end of the item.
  /// 
  public var semicolon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.semicolon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `semicolon` replaced.
  /// - param newChild: The new `semicolon` to replace the node's
  ///                   current `semicolon`, if present.
  public func withSemicolon(
    _ newChild: TokenSyntax?) -> CodeBlockItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.semicolon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.semicolon)
    return CodeBlockItemSyntax(root: root, data: newData)
  }

  /// Determines if two `CodeBlockItemSyntax` nodes are equal to each other.
  public static func ==(lhs: CodeBlockItemSyntax, rhs: CodeBlockItemSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct CodeBlockSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftBrace
    case statements
    case rightBrace
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `CodeBlockSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBrace` replaced.
  /// - param newChild: The new `leftBrace` to replace the node's
  ///                   current `leftBrace`, if present.
  public func withLeftBrace(
    _ newChild: TokenSyntax?) -> CodeBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBrace)
    return CodeBlockSyntax(root: root, data: newData)
  }
  public var statements: CodeBlockItemListSyntax {
    let child = data.cachedChild(at: Cursor.statements)
    return makeSyntax(root: _root, data: child!) as! CodeBlockItemListSyntax
  }

  /// Adds the provided `CodeBlockItem` to the node's `statements`
  /// collection.
  /// - param element: The new `CodeBlockItem` to add to the node's
  ///                  `statements` collection.
  /// - returns: A copy of the receiver with the provided `CodeBlockItem`
  ///            appended to its `statements` collection.
  public func addCodeBlockItem(_ element: CodeBlockItemSyntax) -> CodeBlockSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.statements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.codeBlockItemList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.statements)
    return CodeBlockSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `statements` replaced.
  /// - param newChild: The new `statements` to replace the node's
  ///                   current `statements`, if present.
  public func withStatements(
    _ newChild: CodeBlockItemListSyntax?) -> CodeBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlockItemList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.statements)
    return CodeBlockSyntax(root: root, data: newData)
  }
  public var rightBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBrace` replaced.
  /// - param newChild: The new `rightBrace` to replace the node's
  ///                   current `rightBrace`, if present.
  public func withRightBrace(
    _ newChild: TokenSyntax?) -> CodeBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBrace)
    return CodeBlockSyntax(root: root, data: newData)
  }

  /// Determines if two `CodeBlockSyntax` nodes are equal to each other.
  public static func ==(lhs: CodeBlockSyntax, rhs: CodeBlockSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct InOutExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case ampersand
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `InOutExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var ampersand: TokenSyntax {
    let child = data.cachedChild(at: Cursor.ampersand)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `ampersand` replaced.
  /// - param newChild: The new `ampersand` to replace the node's
  ///                   current `ampersand`, if present.
  public func withAmpersand(
    _ newChild: TokenSyntax?) -> InOutExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.prefixAmpersand)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ampersand)
    return InOutExprSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> InOutExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return InOutExprSyntax(root: root, data: newData)
  }

  /// Determines if two `InOutExprSyntax` nodes are equal to each other.
  public static func ==(lhs: InOutExprSyntax, rhs: InOutExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundColumnExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundColumn
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundColumnExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundColumn: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundColumn)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundColumn` replaced.
  /// - param newChild: The new `poundColumn` to replace the node's
  ///                   current `poundColumn`, if present.
  public func withPoundColumn(
    _ newChild: TokenSyntax?) -> PoundColumnExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundColumnKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundColumn)
    return PoundColumnExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundColumnExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundColumnExprSyntax, rhs: PoundColumnExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TryExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case tryKeyword
    case questionOrExclamationMark
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TryExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var tryKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.tryKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `tryKeyword` replaced.
  /// - param newChild: The new `tryKeyword` to replace the node's
  ///                   current `tryKeyword`, if present.
  public func withTryKeyword(
    _ newChild: TokenSyntax?) -> TryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.tryKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.tryKeyword)
    return TryExprSyntax(root: root, data: newData)
  }
  public var questionOrExclamationMark: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.questionOrExclamationMark)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced.
  /// - param newChild: The new `questionOrExclamationMark` to replace the node's
  ///                   current `questionOrExclamationMark`, if present.
  public func withQuestionOrExclamationMark(
    _ newChild: TokenSyntax?) -> TryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.questionOrExclamationMark)
    return TryExprSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> TryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return TryExprSyntax(root: root, data: newData)
  }

  /// Determines if two `TryExprSyntax` nodes are equal to each other.
  public static func ==(lhs: TryExprSyntax, rhs: TryExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DeclNameArgumentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case colon
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DeclNameArgumentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> DeclNameArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return DeclNameArgumentSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> DeclNameArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return DeclNameArgumentSyntax(root: root, data: newData)
  }

  /// Determines if two `DeclNameArgumentSyntax` nodes are equal to each other.
  public static func ==(lhs: DeclNameArgumentSyntax, rhs: DeclNameArgumentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DeclNameArgumentsSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case arguments
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DeclNameArgumentsSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> DeclNameArgumentsSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return DeclNameArgumentsSyntax(root: root, data: newData)
  }
  public var arguments: DeclNameArgumentListSyntax {
    let child = data.cachedChild(at: Cursor.arguments)
    return makeSyntax(root: _root, data: child!) as! DeclNameArgumentListSyntax
  }

  /// Adds the provided `DeclNameArgument` to the node's `arguments`
  /// collection.
  /// - param element: The new `DeclNameArgument` to add to the node's
  ///                  `arguments` collection.
  /// - returns: A copy of the receiver with the provided `DeclNameArgument`
  ///            appended to its `arguments` collection.
  public func addDeclNameArgument(_ element: DeclNameArgumentSyntax) -> DeclNameArgumentsSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.arguments] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.declNameArgumentList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.arguments)
    return DeclNameArgumentsSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `arguments` replaced.
  /// - param newChild: The new `arguments` to replace the node's
  ///                   current `arguments`, if present.
  public func withArguments(
    _ newChild: DeclNameArgumentListSyntax?) -> DeclNameArgumentsSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.declNameArgumentList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arguments)
    return DeclNameArgumentsSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> DeclNameArgumentsSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return DeclNameArgumentsSyntax(root: root, data: newData)
  }

  /// Determines if two `DeclNameArgumentsSyntax` nodes are equal to each other.
  public static func ==(lhs: DeclNameArgumentsSyntax, rhs: DeclNameArgumentsSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IdentifierExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case identifier
    case declNameArguments
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IdentifierExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> IdentifierExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return IdentifierExprSyntax(root: root, data: newData)
  }
  public var declNameArguments: DeclNameArgumentsSyntax? {
    let child = data.cachedChild(at: Cursor.declNameArguments)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? DeclNameArgumentsSyntax
  }

  /// Returns a copy of the receiver with its `declNameArguments` replaced.
  /// - param newChild: The new `declNameArguments` to replace the node's
  ///                   current `declNameArguments`, if present.
  public func withDeclNameArguments(
    _ newChild: DeclNameArgumentsSyntax?) -> IdentifierExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.declNameArguments)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.declNameArguments)
    return IdentifierExprSyntax(root: root, data: newData)
  }

  /// Determines if two `IdentifierExprSyntax` nodes are equal to each other.
  public static func ==(lhs: IdentifierExprSyntax, rhs: IdentifierExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SuperRefExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case superKeyword
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SuperRefExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var superKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.superKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `superKeyword` replaced.
  /// - param newChild: The new `superKeyword` to replace the node's
  ///                   current `superKeyword`, if present.
  public func withSuperKeyword(
    _ newChild: TokenSyntax?) -> SuperRefExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.superKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.superKeyword)
    return SuperRefExprSyntax(root: root, data: newData)
  }

  /// Determines if two `SuperRefExprSyntax` nodes are equal to each other.
  public static func ==(lhs: SuperRefExprSyntax, rhs: SuperRefExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct NilLiteralExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case nilKeyword
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `NilLiteralExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var nilKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.nilKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `nilKeyword` replaced.
  /// - param newChild: The new `nilKeyword` to replace the node's
  ///                   current `nilKeyword`, if present.
  public func withNilKeyword(
    _ newChild: TokenSyntax?) -> NilLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.nilKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.nilKeyword)
    return NilLiteralExprSyntax(root: root, data: newData)
  }

  /// Determines if two `NilLiteralExprSyntax` nodes are equal to each other.
  public static func ==(lhs: NilLiteralExprSyntax, rhs: NilLiteralExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DiscardAssignmentExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case wildcard
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DiscardAssignmentExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var wildcard: TokenSyntax {
    let child = data.cachedChild(at: Cursor.wildcard)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `wildcard` replaced.
  /// - param newChild: The new `wildcard` to replace the node's
  ///                   current `wildcard`, if present.
  public func withWildcard(
    _ newChild: TokenSyntax?) -> DiscardAssignmentExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.wildcardKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.wildcard)
    return DiscardAssignmentExprSyntax(root: root, data: newData)
  }

  /// Determines if two `DiscardAssignmentExprSyntax` nodes are equal to each other.
  public static func ==(lhs: DiscardAssignmentExprSyntax, rhs: DiscardAssignmentExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AssignmentExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case assignToken
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AssignmentExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var assignToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.assignToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `assignToken` replaced.
  /// - param newChild: The new `assignToken` to replace the node's
  ///                   current `assignToken`, if present.
  public func withAssignToken(
    _ newChild: TokenSyntax?) -> AssignmentExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.equal)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.assignToken)
    return AssignmentExprSyntax(root: root, data: newData)
  }

  /// Determines if two `AssignmentExprSyntax` nodes are equal to each other.
  public static func ==(lhs: AssignmentExprSyntax, rhs: AssignmentExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SequenceExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case elements
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SequenceExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var elements: ExprListSyntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) as! ExprListSyntax
  }

  /// Adds the provided `Expression` to the node's `elements`
  /// collection.
  /// - param element: The new `Expression` to add to the node's
  ///                  `elements` collection.
  /// - returns: A copy of the receiver with the provided `Expression`
  ///            appended to its `elements` collection.
  public func addExpression(_ element: ExprSyntax) -> SequenceExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.exprList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elements)
    return SequenceExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: ExprListSyntax?) -> SequenceExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.exprList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return SequenceExprSyntax(root: root, data: newData)
  }

  /// Determines if two `SequenceExprSyntax` nodes are equal to each other.
  public static func ==(lhs: SequenceExprSyntax, rhs: SequenceExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundLineExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundLine
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundLineExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundLine: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundLine)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundLine` replaced.
  /// - param newChild: The new `poundLine` to replace the node's
  ///                   current `poundLine`, if present.
  public func withPoundLine(
    _ newChild: TokenSyntax?) -> PoundLineExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundLineKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundLine)
    return PoundLineExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundLineExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundLineExprSyntax, rhs: PoundLineExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundFileExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundFile
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundFileExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundFile: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundFile)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundFile` replaced.
  /// - param newChild: The new `poundFile` to replace the node's
  ///                   current `poundFile`, if present.
  public func withPoundFile(
    _ newChild: TokenSyntax?) -> PoundFileExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundFileKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundFile)
    return PoundFileExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundFileExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundFileExprSyntax, rhs: PoundFileExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundFunctionExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundFunction
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundFunctionExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundFunction: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundFunction)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundFunction` replaced.
  /// - param newChild: The new `poundFunction` to replace the node's
  ///                   current `poundFunction`, if present.
  public func withPoundFunction(
    _ newChild: TokenSyntax?) -> PoundFunctionExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundFunctionKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundFunction)
    return PoundFunctionExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundFunctionExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundFunctionExprSyntax, rhs: PoundFunctionExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundDsohandleExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundDsohandle
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundDsohandleExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundDsohandle: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundDsohandle)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundDsohandle` replaced.
  /// - param newChild: The new `poundDsohandle` to replace the node's
  ///                   current `poundDsohandle`, if present.
  public func withPoundDsohandle(
    _ newChild: TokenSyntax?) -> PoundDsohandleExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundDsohandleKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundDsohandle)
    return PoundDsohandleExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundDsohandleExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundDsohandleExprSyntax, rhs: PoundDsohandleExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SymbolicReferenceExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case identifier
    case genericArgumentClause
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SymbolicReferenceExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> SymbolicReferenceExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return SymbolicReferenceExprSyntax(root: root, data: newData)
  }
  public var genericArgumentClause: GenericArgumentClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericArgumentClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericArgumentClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericArgumentClause` replaced.
  /// - param newChild: The new `genericArgumentClause` to replace the node's
  ///                   current `genericArgumentClause`, if present.
  public func withGenericArgumentClause(
    _ newChild: GenericArgumentClauseSyntax?) -> SymbolicReferenceExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericArgumentClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericArgumentClause)
    return SymbolicReferenceExprSyntax(root: root, data: newData)
  }

  /// Determines if two `SymbolicReferenceExprSyntax` nodes are equal to each other.
  public static func ==(lhs: SymbolicReferenceExprSyntax, rhs: SymbolicReferenceExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PrefixOperatorExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case operatorToken
    case postfixExpression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PrefixOperatorExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var operatorToken: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.operatorToken)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `operatorToken` replaced.
  /// - param newChild: The new `operatorToken` to replace the node's
  ///                   current `operatorToken`, if present.
  public func withOperatorToken(
    _ newChild: TokenSyntax?) -> PrefixOperatorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.prefixOperator(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.operatorToken)
    return PrefixOperatorExprSyntax(root: root, data: newData)
  }
  public var postfixExpression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.postfixExpression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `postfixExpression` replaced.
  /// - param newChild: The new `postfixExpression` to replace the node's
  ///                   current `postfixExpression`, if present.
  public func withPostfixExpression(
    _ newChild: ExprSyntax?) -> PrefixOperatorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.postfixExpression)
    return PrefixOperatorExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PrefixOperatorExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PrefixOperatorExprSyntax, rhs: PrefixOperatorExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct BinaryOperatorExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case operatorToken
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `BinaryOperatorExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var operatorToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.operatorToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `operatorToken` replaced.
  /// - param newChild: The new `operatorToken` to replace the node's
  ///                   current `operatorToken`, if present.
  public func withOperatorToken(
    _ newChild: TokenSyntax?) -> BinaryOperatorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.operatorToken)
    return BinaryOperatorExprSyntax(root: root, data: newData)
  }

  /// Determines if two `BinaryOperatorExprSyntax` nodes are equal to each other.
  public static func ==(lhs: BinaryOperatorExprSyntax, rhs: BinaryOperatorExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ArrowExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case throwsToken
    case arrowToken
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ArrowExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var throwsToken: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.throwsToken)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `throwsToken` replaced.
  /// - param newChild: The new `throwsToken` to replace the node's
  ///                   current `throwsToken`, if present.
  public func withThrowsToken(
    _ newChild: TokenSyntax?) -> ArrowExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.throwsKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.throwsToken)
    return ArrowExprSyntax(root: root, data: newData)
  }
  public var arrowToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.arrowToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `arrowToken` replaced.
  /// - param newChild: The new `arrowToken` to replace the node's
  ///                   current `arrowToken`, if present.
  public func withArrowToken(
    _ newChild: TokenSyntax?) -> ArrowExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.arrow)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arrowToken)
    return ArrowExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ArrowExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ArrowExprSyntax, rhs: ArrowExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FloatLiteralExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case floatingDigits
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FloatLiteralExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var floatingDigits: TokenSyntax {
    let child = data.cachedChild(at: Cursor.floatingDigits)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `floatingDigits` replaced.
  /// - param newChild: The new `floatingDigits` to replace the node's
  ///                   current `floatingDigits`, if present.
  public func withFloatingDigits(
    _ newChild: TokenSyntax?) -> FloatLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.floatingLiteral(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.floatingDigits)
    return FloatLiteralExprSyntax(root: root, data: newData)
  }

  /// Determines if two `FloatLiteralExprSyntax` nodes are equal to each other.
  public static func ==(lhs: FloatLiteralExprSyntax, rhs: FloatLiteralExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TupleExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case elementList
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TupleExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> TupleExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return TupleExprSyntax(root: root, data: newData)
  }
  public var elementList: TupleElementListSyntax {
    let child = data.cachedChild(at: Cursor.elementList)
    return makeSyntax(root: _root, data: child!) as! TupleElementListSyntax
  }

  /// Adds the provided `TupleElement` to the node's `elementList`
  /// collection.
  /// - param element: The new `TupleElement` to add to the node's
  ///                  `elementList` collection.
  /// - returns: A copy of the receiver with the provided `TupleElement`
  ///            appended to its `elementList` collection.
  public func addTupleElement(_ element: TupleElementSyntax) -> TupleExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elementList] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tupleElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elementList)
    return TupleExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elementList` replaced.
  /// - param newChild: The new `elementList` to replace the node's
  ///                   current `elementList`, if present.
  public func withElementList(
    _ newChild: TupleElementListSyntax?) -> TupleExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.tupleElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elementList)
    return TupleExprSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> TupleExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return TupleExprSyntax(root: root, data: newData)
  }

  /// Determines if two `TupleExprSyntax` nodes are equal to each other.
  public static func ==(lhs: TupleExprSyntax, rhs: TupleExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ArrayExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftSquare
    case elements
    case rightSquare
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ArrayExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftSquare: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftSquare)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftSquare` replaced.
  /// - param newChild: The new `leftSquare` to replace the node's
  ///                   current `leftSquare`, if present.
  public func withLeftSquare(
    _ newChild: TokenSyntax?) -> ArrayExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftSquare)
    return ArrayExprSyntax(root: root, data: newData)
  }
  public var elements: ArrayElementListSyntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) as! ArrayElementListSyntax
  }

  /// Adds the provided `ArrayElement` to the node's `elements`
  /// collection.
  /// - param element: The new `ArrayElement` to add to the node's
  ///                  `elements` collection.
  /// - returns: A copy of the receiver with the provided `ArrayElement`
  ///            appended to its `elements` collection.
  public func addArrayElement(_ element: ArrayElementSyntax) -> ArrayExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.arrayElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elements)
    return ArrayExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: ArrayElementListSyntax?) -> ArrayExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.arrayElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return ArrayExprSyntax(root: root, data: newData)
  }
  public var rightSquare: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightSquare)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightSquare` replaced.
  /// - param newChild: The new `rightSquare` to replace the node's
  ///                   current `rightSquare`, if present.
  public func withRightSquare(
    _ newChild: TokenSyntax?) -> ArrayExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightSquare)
    return ArrayExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ArrayExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ArrayExprSyntax, rhs: ArrayExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DictionaryExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftSquare
    case content
    case rightSquare
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DictionaryExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftSquare: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftSquare)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftSquare` replaced.
  /// - param newChild: The new `leftSquare` to replace the node's
  ///                   current `leftSquare`, if present.
  public func withLeftSquare(
    _ newChild: TokenSyntax?) -> DictionaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftSquare)
    return DictionaryExprSyntax(root: root, data: newData)
  }
  public var content: Syntax {
    let child = data.cachedChild(at: Cursor.content)
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `content` replaced.
  /// - param newChild: The new `content` to replace the node's
  ///                   current `content`, if present.
  public func withContent(
    _ newChild: Syntax?) -> DictionaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.content)
    return DictionaryExprSyntax(root: root, data: newData)
  }
  public var rightSquare: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightSquare)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightSquare` replaced.
  /// - param newChild: The new `rightSquare` to replace the node's
  ///                   current `rightSquare`, if present.
  public func withRightSquare(
    _ newChild: TokenSyntax?) -> DictionaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightSquare)
    return DictionaryExprSyntax(root: root, data: newData)
  }

  /// Determines if two `DictionaryExprSyntax` nodes are equal to each other.
  public static func ==(lhs: DictionaryExprSyntax, rhs: DictionaryExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ImplicitMemberExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case dot
    case name
    case declNameArguments
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ImplicitMemberExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var dot: TokenSyntax {
    let child = data.cachedChild(at: Cursor.dot)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `dot` replaced.
  /// - param newChild: The new `dot` to replace the node's
  ///                   current `dot`, if present.
  public func withDot(
    _ newChild: TokenSyntax?) -> ImplicitMemberExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.prefixPeriod)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.dot)
    return ImplicitMemberExprSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> ImplicitMemberExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return ImplicitMemberExprSyntax(root: root, data: newData)
  }
  public var declNameArguments: DeclNameArgumentsSyntax? {
    let child = data.cachedChild(at: Cursor.declNameArguments)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? DeclNameArgumentsSyntax
  }

  /// Returns a copy of the receiver with its `declNameArguments` replaced.
  /// - param newChild: The new `declNameArguments` to replace the node's
  ///                   current `declNameArguments`, if present.
  public func withDeclNameArguments(
    _ newChild: DeclNameArgumentsSyntax?) -> ImplicitMemberExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.declNameArguments)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.declNameArguments)
    return ImplicitMemberExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ImplicitMemberExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ImplicitMemberExprSyntax, rhs: ImplicitMemberExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FunctionCallArgumentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case label
    case colon
    case expression
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionCallArgumentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var label: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.label)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `label` replaced.
  /// - param newChild: The new `label` to replace the node's
  ///                   current `label`, if present.
  public func withLabel(
    _ newChild: TokenSyntax?) -> FunctionCallArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.label)
    return FunctionCallArgumentSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> FunctionCallArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return FunctionCallArgumentSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> FunctionCallArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return FunctionCallArgumentSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> FunctionCallArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return FunctionCallArgumentSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionCallArgumentSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionCallArgumentSyntax, rhs: FunctionCallArgumentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TupleElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case label
    case colon
    case expression
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TupleElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var label: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.label)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `label` replaced.
  /// - param newChild: The new `label` to replace the node's
  ///                   current `label`, if present.
  public func withLabel(
    _ newChild: TokenSyntax?) -> TupleElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.label)
    return TupleElementSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> TupleElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return TupleElementSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> TupleElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return TupleElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> TupleElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return TupleElementSyntax(root: root, data: newData)
  }

  /// Determines if two `TupleElementSyntax` nodes are equal to each other.
  public static func ==(lhs: TupleElementSyntax, rhs: TupleElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ArrayElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ArrayElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ArrayElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ArrayElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> ArrayElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return ArrayElementSyntax(root: root, data: newData)
  }

  /// Determines if two `ArrayElementSyntax` nodes are equal to each other.
  public static func ==(lhs: ArrayElementSyntax, rhs: ArrayElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DictionaryElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case keyExpression
    case colon
    case valueExpression
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DictionaryElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var keyExpression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.keyExpression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `keyExpression` replaced.
  /// - param newChild: The new `keyExpression` to replace the node's
  ///                   current `keyExpression`, if present.
  public func withKeyExpression(
    _ newChild: ExprSyntax?) -> DictionaryElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.keyExpression)
    return DictionaryElementSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> DictionaryElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return DictionaryElementSyntax(root: root, data: newData)
  }
  public var valueExpression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.valueExpression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `valueExpression` replaced.
  /// - param newChild: The new `valueExpression` to replace the node's
  ///                   current `valueExpression`, if present.
  public func withValueExpression(
    _ newChild: ExprSyntax?) -> DictionaryElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.valueExpression)
    return DictionaryElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> DictionaryElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return DictionaryElementSyntax(root: root, data: newData)
  }

  /// Determines if two `DictionaryElementSyntax` nodes are equal to each other.
  public static func ==(lhs: DictionaryElementSyntax, rhs: DictionaryElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IntegerLiteralExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case digits
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IntegerLiteralExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var digits: TokenSyntax {
    let child = data.cachedChild(at: Cursor.digits)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `digits` replaced.
  /// - param newChild: The new `digits` to replace the node's
  ///                   current `digits`, if present.
  public func withDigits(
    _ newChild: TokenSyntax?) -> IntegerLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.integerLiteral(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.digits)
    return IntegerLiteralExprSyntax(root: root, data: newData)
  }

  /// Determines if two `IntegerLiteralExprSyntax` nodes are equal to each other.
  public static func ==(lhs: IntegerLiteralExprSyntax, rhs: IntegerLiteralExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct StringLiteralExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case stringLiteral
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `StringLiteralExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var stringLiteral: TokenSyntax {
    let child = data.cachedChild(at: Cursor.stringLiteral)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `stringLiteral` replaced.
  /// - param newChild: The new `stringLiteral` to replace the node's
  ///                   current `stringLiteral`, if present.
  public func withStringLiteral(
    _ newChild: TokenSyntax?) -> StringLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.stringLiteral(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.stringLiteral)
    return StringLiteralExprSyntax(root: root, data: newData)
  }

  /// Determines if two `StringLiteralExprSyntax` nodes are equal to each other.
  public static func ==(lhs: StringLiteralExprSyntax, rhs: StringLiteralExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct BooleanLiteralExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case booleanLiteral
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `BooleanLiteralExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var booleanLiteral: TokenSyntax {
    let child = data.cachedChild(at: Cursor.booleanLiteral)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `booleanLiteral` replaced.
  /// - param newChild: The new `booleanLiteral` to replace the node's
  ///                   current `booleanLiteral`, if present.
  public func withBooleanLiteral(
    _ newChild: TokenSyntax?) -> BooleanLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.trueKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.booleanLiteral)
    return BooleanLiteralExprSyntax(root: root, data: newData)
  }

  /// Determines if two `BooleanLiteralExprSyntax` nodes are equal to each other.
  public static func ==(lhs: BooleanLiteralExprSyntax, rhs: BooleanLiteralExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TernaryExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case conditionExpression
    case questionMark
    case firstChoice
    case colonMark
    case secondChoice
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TernaryExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var conditionExpression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.conditionExpression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `conditionExpression` replaced.
  /// - param newChild: The new `conditionExpression` to replace the node's
  ///                   current `conditionExpression`, if present.
  public func withConditionExpression(
    _ newChild: ExprSyntax?) -> TernaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.conditionExpression)
    return TernaryExprSyntax(root: root, data: newData)
  }
  public var questionMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.questionMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `questionMark` replaced.
  /// - param newChild: The new `questionMark` to replace the node's
  ///                   current `questionMark`, if present.
  public func withQuestionMark(
    _ newChild: TokenSyntax?) -> TernaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.infixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.questionMark)
    return TernaryExprSyntax(root: root, data: newData)
  }
  public var firstChoice: ExprSyntax {
    let child = data.cachedChild(at: Cursor.firstChoice)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `firstChoice` replaced.
  /// - param newChild: The new `firstChoice` to replace the node's
  ///                   current `firstChoice`, if present.
  public func withFirstChoice(
    _ newChild: ExprSyntax?) -> TernaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.firstChoice)
    return TernaryExprSyntax(root: root, data: newData)
  }
  public var colonMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colonMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colonMark` replaced.
  /// - param newChild: The new `colonMark` to replace the node's
  ///                   current `colonMark`, if present.
  public func withColonMark(
    _ newChild: TokenSyntax?) -> TernaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colonMark)
    return TernaryExprSyntax(root: root, data: newData)
  }
  public var secondChoice: ExprSyntax {
    let child = data.cachedChild(at: Cursor.secondChoice)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `secondChoice` replaced.
  /// - param newChild: The new `secondChoice` to replace the node's
  ///                   current `secondChoice`, if present.
  public func withSecondChoice(
    _ newChild: ExprSyntax?) -> TernaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.secondChoice)
    return TernaryExprSyntax(root: root, data: newData)
  }

  /// Determines if two `TernaryExprSyntax` nodes are equal to each other.
  public static func ==(lhs: TernaryExprSyntax, rhs: TernaryExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct MemberAccessExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case base
    case dot
    case name
    case declNameArguments
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `MemberAccessExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var base: ExprSyntax {
    let child = data.cachedChild(at: Cursor.base)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `base` replaced.
  /// - param newChild: The new `base` to replace the node's
  ///                   current `base`, if present.
  public func withBase(
    _ newChild: ExprSyntax?) -> MemberAccessExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.base)
    return MemberAccessExprSyntax(root: root, data: newData)
  }
  public var dot: TokenSyntax {
    let child = data.cachedChild(at: Cursor.dot)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `dot` replaced.
  /// - param newChild: The new `dot` to replace the node's
  ///                   current `dot`, if present.
  public func withDot(
    _ newChild: TokenSyntax?) -> MemberAccessExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.dot)
    return MemberAccessExprSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> MemberAccessExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return MemberAccessExprSyntax(root: root, data: newData)
  }
  public var declNameArguments: DeclNameArgumentsSyntax? {
    let child = data.cachedChild(at: Cursor.declNameArguments)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? DeclNameArgumentsSyntax
  }

  /// Returns a copy of the receiver with its `declNameArguments` replaced.
  /// - param newChild: The new `declNameArguments` to replace the node's
  ///                   current `declNameArguments`, if present.
  public func withDeclNameArguments(
    _ newChild: DeclNameArgumentsSyntax?) -> MemberAccessExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.declNameArguments)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.declNameArguments)
    return MemberAccessExprSyntax(root: root, data: newData)
  }

  /// Determines if two `MemberAccessExprSyntax` nodes are equal to each other.
  public static func ==(lhs: MemberAccessExprSyntax, rhs: MemberAccessExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DotSelfExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
    case dot
    case selfKeyword
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DotSelfExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> DotSelfExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return DotSelfExprSyntax(root: root, data: newData)
  }
  public var dot: TokenSyntax {
    let child = data.cachedChild(at: Cursor.dot)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `dot` replaced.
  /// - param newChild: The new `dot` to replace the node's
  ///                   current `dot`, if present.
  public func withDot(
    _ newChild: TokenSyntax?) -> DotSelfExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.dot)
    return DotSelfExprSyntax(root: root, data: newData)
  }
  public var selfKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.selfKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `selfKeyword` replaced.
  /// - param newChild: The new `selfKeyword` to replace the node's
  ///                   current `selfKeyword`, if present.
  public func withSelfKeyword(
    _ newChild: TokenSyntax?) -> DotSelfExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.selfKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.selfKeyword)
    return DotSelfExprSyntax(root: root, data: newData)
  }

  /// Determines if two `DotSelfExprSyntax` nodes are equal to each other.
  public static func ==(lhs: DotSelfExprSyntax, rhs: DotSelfExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IsExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case isTok
    case typeName
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IsExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var isTok: TokenSyntax {
    let child = data.cachedChild(at: Cursor.isTok)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `isTok` replaced.
  /// - param newChild: The new `isTok` to replace the node's
  ///                   current `isTok`, if present.
  public func withIsTok(
    _ newChild: TokenSyntax?) -> IsExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.isKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.isTok)
    return IsExprSyntax(root: root, data: newData)
  }
  public var typeName: TypeSyntax {
    let child = data.cachedChild(at: Cursor.typeName)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `typeName` replaced.
  /// - param newChild: The new `typeName` to replace the node's
  ///                   current `typeName`, if present.
  public func withTypeName(
    _ newChild: TypeSyntax?) -> IsExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeName)
    return IsExprSyntax(root: root, data: newData)
  }

  /// Determines if two `IsExprSyntax` nodes are equal to each other.
  public static func ==(lhs: IsExprSyntax, rhs: IsExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AsExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case asTok
    case questionOrExclamationMark
    case typeName
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AsExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var asTok: TokenSyntax {
    let child = data.cachedChild(at: Cursor.asTok)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `asTok` replaced.
  /// - param newChild: The new `asTok` to replace the node's
  ///                   current `asTok`, if present.
  public func withAsTok(
    _ newChild: TokenSyntax?) -> AsExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.asKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.asTok)
    return AsExprSyntax(root: root, data: newData)
  }
  public var questionOrExclamationMark: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.questionOrExclamationMark)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `questionOrExclamationMark` replaced.
  /// - param newChild: The new `questionOrExclamationMark` to replace the node's
  ///                   current `questionOrExclamationMark`, if present.
  public func withQuestionOrExclamationMark(
    _ newChild: TokenSyntax?) -> AsExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.questionOrExclamationMark)
    return AsExprSyntax(root: root, data: newData)
  }
  public var typeName: TypeSyntax {
    let child = data.cachedChild(at: Cursor.typeName)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `typeName` replaced.
  /// - param newChild: The new `typeName` to replace the node's
  ///                   current `typeName`, if present.
  public func withTypeName(
    _ newChild: TypeSyntax?) -> AsExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeName)
    return AsExprSyntax(root: root, data: newData)
  }

  /// Determines if two `AsExprSyntax` nodes are equal to each other.
  public static func ==(lhs: AsExprSyntax, rhs: AsExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TypeExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case type
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TypeExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var type: TypeSyntax {
    let child = data.cachedChild(at: Cursor.type)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> TypeExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return TypeExprSyntax(root: root, data: newData)
  }

  /// Determines if two `TypeExprSyntax` nodes are equal to each other.
  public static func ==(lhs: TypeExprSyntax, rhs: TypeExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ClosureCaptureItemSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case specifier
    case name
    case assignToken
    case expression
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ClosureCaptureItemSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var specifier: TokenListSyntax? {
    let child = data.cachedChild(at: Cursor.specifier)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenListSyntax
  }

  /// Adds the provided `Token` to the node's `specifier`
  /// collection.
  /// - param element: The new `Token` to add to the node's
  ///                  `specifier` collection.
  /// - returns: A copy of the receiver with the provided `Token`
  ///            appended to its `specifier` collection.
  public func addToken(_ element: TokenSyntax) -> ClosureCaptureItemSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.specifier] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tokenList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.specifier)
    return ClosureCaptureItemSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `specifier` replaced.
  /// - param newChild: The new `specifier` to replace the node's
  ///                   current `specifier`, if present.
  public func withSpecifier(
    _ newChild: TokenListSyntax?) -> ClosureCaptureItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.specifier)
    return ClosureCaptureItemSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.name)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return ClosureCaptureItemSyntax(root: root, data: newData)
  }
  public var assignToken: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.assignToken)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `assignToken` replaced.
  /// - param newChild: The new `assignToken` to replace the node's
  ///                   current `assignToken`, if present.
  public func withAssignToken(
    _ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.equal)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.assignToken)
    return ClosureCaptureItemSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ClosureCaptureItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ClosureCaptureItemSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> ClosureCaptureItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return ClosureCaptureItemSyntax(root: root, data: newData)
  }

  /// Determines if two `ClosureCaptureItemSyntax` nodes are equal to each other.
  public static func ==(lhs: ClosureCaptureItemSyntax, rhs: ClosureCaptureItemSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ClosureCaptureSignatureSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftSquare
    case items
    case rightSquare
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ClosureCaptureSignatureSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftSquare: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftSquare)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftSquare` replaced.
  /// - param newChild: The new `leftSquare` to replace the node's
  ///                   current `leftSquare`, if present.
  public func withLeftSquare(
    _ newChild: TokenSyntax?) -> ClosureCaptureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftSquare)
    return ClosureCaptureSignatureSyntax(root: root, data: newData)
  }
  public var items: ClosureCaptureItemListSyntax? {
    let child = data.cachedChild(at: Cursor.items)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ClosureCaptureItemListSyntax
  }

  /// Adds the provided `ClosureCaptureItem` to the node's `items`
  /// collection.
  /// - param element: The new `ClosureCaptureItem` to add to the node's
  ///                  `items` collection.
  /// - returns: A copy of the receiver with the provided `ClosureCaptureItem`
  ///            appended to its `items` collection.
  public func addClosureCaptureItem(_ element: ClosureCaptureItemSyntax) -> ClosureCaptureSignatureSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.items] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.closureCaptureItemList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.items)
    return ClosureCaptureSignatureSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `items` replaced.
  /// - param newChild: The new `items` to replace the node's
  ///                   current `items`, if present.
  public func withItems(
    _ newChild: ClosureCaptureItemListSyntax?) -> ClosureCaptureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.closureCaptureItemList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.items)
    return ClosureCaptureSignatureSyntax(root: root, data: newData)
  }
  public var rightSquare: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightSquare)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightSquare` replaced.
  /// - param newChild: The new `rightSquare` to replace the node's
  ///                   current `rightSquare`, if present.
  public func withRightSquare(
    _ newChild: TokenSyntax?) -> ClosureCaptureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightSquare)
    return ClosureCaptureSignatureSyntax(root: root, data: newData)
  }

  /// Determines if two `ClosureCaptureSignatureSyntax` nodes are equal to each other.
  public static func ==(lhs: ClosureCaptureSignatureSyntax, rhs: ClosureCaptureSignatureSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ClosureParamSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ClosureParamSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> ClosureParamSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return ClosureParamSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> ClosureParamSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return ClosureParamSyntax(root: root, data: newData)
  }

  /// Determines if two `ClosureParamSyntax` nodes are equal to each other.
  public static func ==(lhs: ClosureParamSyntax, rhs: ClosureParamSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ClosureSignatureSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case capture
    case input
    case throwsTok
    case output
    case inTok
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ClosureSignatureSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var capture: ClosureCaptureSignatureSyntax? {
    let child = data.cachedChild(at: Cursor.capture)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ClosureCaptureSignatureSyntax
  }

  /// Returns a copy of the receiver with its `capture` replaced.
  /// - param newChild: The new `capture` to replace the node's
  ///                   current `capture`, if present.
  public func withCapture(
    _ newChild: ClosureCaptureSignatureSyntax?) -> ClosureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.closureCaptureSignature)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.capture)
    return ClosureSignatureSyntax(root: root, data: newData)
  }
  public var input: Syntax? {
    let child = data.cachedChild(at: Cursor.input)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `input` replaced.
  /// - param newChild: The new `input` to replace the node's
  ///                   current `input`, if present.
  public func withInput(
    _ newChild: Syntax?) -> ClosureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.input)
    return ClosureSignatureSyntax(root: root, data: newData)
  }
  public var throwsTok: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.throwsTok)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `throwsTok` replaced.
  /// - param newChild: The new `throwsTok` to replace the node's
  ///                   current `throwsTok`, if present.
  public func withThrowsTok(
    _ newChild: TokenSyntax?) -> ClosureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.throwsKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.throwsTok)
    return ClosureSignatureSyntax(root: root, data: newData)
  }
  public var output: ReturnClauseSyntax? {
    let child = data.cachedChild(at: Cursor.output)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ReturnClauseSyntax
  }

  /// Returns a copy of the receiver with its `output` replaced.
  /// - param newChild: The new `output` to replace the node's
  ///                   current `output`, if present.
  public func withOutput(
    _ newChild: ReturnClauseSyntax?) -> ClosureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.returnClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.output)
    return ClosureSignatureSyntax(root: root, data: newData)
  }
  public var inTok: TokenSyntax {
    let child = data.cachedChild(at: Cursor.inTok)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `inTok` replaced.
  /// - param newChild: The new `inTok` to replace the node's
  ///                   current `inTok`, if present.
  public func withInTok(
    _ newChild: TokenSyntax?) -> ClosureSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.inKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inTok)
    return ClosureSignatureSyntax(root: root, data: newData)
  }

  /// Determines if two `ClosureSignatureSyntax` nodes are equal to each other.
  public static func ==(lhs: ClosureSignatureSyntax, rhs: ClosureSignatureSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ClosureExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftBrace
    case signature
    case statements
    case rightBrace
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ClosureExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBrace` replaced.
  /// - param newChild: The new `leftBrace` to replace the node's
  ///                   current `leftBrace`, if present.
  public func withLeftBrace(
    _ newChild: TokenSyntax?) -> ClosureExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBrace)
    return ClosureExprSyntax(root: root, data: newData)
  }
  public var signature: ClosureSignatureSyntax? {
    let child = data.cachedChild(at: Cursor.signature)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ClosureSignatureSyntax
  }

  /// Returns a copy of the receiver with its `signature` replaced.
  /// - param newChild: The new `signature` to replace the node's
  ///                   current `signature`, if present.
  public func withSignature(
    _ newChild: ClosureSignatureSyntax?) -> ClosureExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.closureSignature)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.signature)
    return ClosureExprSyntax(root: root, data: newData)
  }
  public var statements: CodeBlockItemListSyntax {
    let child = data.cachedChild(at: Cursor.statements)
    return makeSyntax(root: _root, data: child!) as! CodeBlockItemListSyntax
  }

  /// Adds the provided `CodeBlockItem` to the node's `statements`
  /// collection.
  /// - param element: The new `CodeBlockItem` to add to the node's
  ///                  `statements` collection.
  /// - returns: A copy of the receiver with the provided `CodeBlockItem`
  ///            appended to its `statements` collection.
  public func addCodeBlockItem(_ element: CodeBlockItemSyntax) -> ClosureExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.statements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.codeBlockItemList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.statements)
    return ClosureExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `statements` replaced.
  /// - param newChild: The new `statements` to replace the node's
  ///                   current `statements`, if present.
  public func withStatements(
    _ newChild: CodeBlockItemListSyntax?) -> ClosureExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlockItemList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.statements)
    return ClosureExprSyntax(root: root, data: newData)
  }
  public var rightBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBrace` replaced.
  /// - param newChild: The new `rightBrace` to replace the node's
  ///                   current `rightBrace`, if present.
  public func withRightBrace(
    _ newChild: TokenSyntax?) -> ClosureExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBrace)
    return ClosureExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ClosureExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ClosureExprSyntax, rhs: ClosureExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct UnresolvedPatternExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case pattern
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `UnresolvedPatternExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> UnresolvedPatternExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return UnresolvedPatternExprSyntax(root: root, data: newData)
  }

  /// Determines if two `UnresolvedPatternExprSyntax` nodes are equal to each other.
  public static func ==(lhs: UnresolvedPatternExprSyntax, rhs: UnresolvedPatternExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FunctionCallExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case calledExpression
    case leftParen
    case argumentList
    case rightParen
    case trailingClosure
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionCallExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var calledExpression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.calledExpression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `calledExpression` replaced.
  /// - param newChild: The new `calledExpression` to replace the node's
  ///                   current `calledExpression`, if present.
  public func withCalledExpression(
    _ newChild: ExprSyntax?) -> FunctionCallExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.calledExpression)
    return FunctionCallExprSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.leftParen)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> FunctionCallExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return FunctionCallExprSyntax(root: root, data: newData)
  }
  public var argumentList: FunctionCallArgumentListSyntax {
    let child = data.cachedChild(at: Cursor.argumentList)
    return makeSyntax(root: _root, data: child!) as! FunctionCallArgumentListSyntax
  }

  /// Adds the provided `FunctionCallArgument` to the node's `argumentList`
  /// collection.
  /// - param element: The new `FunctionCallArgument` to add to the node's
  ///                  `argumentList` collection.
  /// - returns: A copy of the receiver with the provided `FunctionCallArgument`
  ///            appended to its `argumentList` collection.
  public func addFunctionCallArgument(_ element: FunctionCallArgumentSyntax) -> FunctionCallExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.argumentList] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.functionCallArgumentList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.argumentList)
    return FunctionCallExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `argumentList` replaced.
  /// - param newChild: The new `argumentList` to replace the node's
  ///                   current `argumentList`, if present.
  public func withArgumentList(
    _ newChild: FunctionCallArgumentListSyntax?) -> FunctionCallExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.functionCallArgumentList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.argumentList)
    return FunctionCallExprSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.rightParen)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> FunctionCallExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return FunctionCallExprSyntax(root: root, data: newData)
  }
  public var trailingClosure: ClosureExprSyntax? {
    let child = data.cachedChild(at: Cursor.trailingClosure)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ClosureExprSyntax
  }

  /// Returns a copy of the receiver with its `trailingClosure` replaced.
  /// - param newChild: The new `trailingClosure` to replace the node's
  ///                   current `trailingClosure`, if present.
  public func withTrailingClosure(
    _ newChild: ClosureExprSyntax?) -> FunctionCallExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.closureExpr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingClosure)
    return FunctionCallExprSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionCallExprSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionCallExprSyntax, rhs: FunctionCallExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SubscriptExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case calledExpression
    case leftBracket
    case argumentList
    case rightBracket
    case trailingClosure
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SubscriptExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var calledExpression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.calledExpression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `calledExpression` replaced.
  /// - param newChild: The new `calledExpression` to replace the node's
  ///                   current `calledExpression`, if present.
  public func withCalledExpression(
    _ newChild: ExprSyntax?) -> SubscriptExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.calledExpression)
    return SubscriptExprSyntax(root: root, data: newData)
  }
  public var leftBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBracket` replaced.
  /// - param newChild: The new `leftBracket` to replace the node's
  ///                   current `leftBracket`, if present.
  public func withLeftBracket(
    _ newChild: TokenSyntax?) -> SubscriptExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBracket)
    return SubscriptExprSyntax(root: root, data: newData)
  }
  public var argumentList: FunctionCallArgumentListSyntax {
    let child = data.cachedChild(at: Cursor.argumentList)
    return makeSyntax(root: _root, data: child!) as! FunctionCallArgumentListSyntax
  }

  /// Adds the provided `FunctionCallArgument` to the node's `argumentList`
  /// collection.
  /// - param element: The new `FunctionCallArgument` to add to the node's
  ///                  `argumentList` collection.
  /// - returns: A copy of the receiver with the provided `FunctionCallArgument`
  ///            appended to its `argumentList` collection.
  public func addFunctionCallArgument(_ element: FunctionCallArgumentSyntax) -> SubscriptExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.argumentList] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.functionCallArgumentList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.argumentList)
    return SubscriptExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `argumentList` replaced.
  /// - param newChild: The new `argumentList` to replace the node's
  ///                   current `argumentList`, if present.
  public func withArgumentList(
    _ newChild: FunctionCallArgumentListSyntax?) -> SubscriptExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.functionCallArgumentList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.argumentList)
    return SubscriptExprSyntax(root: root, data: newData)
  }
  public var rightBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBracket` replaced.
  /// - param newChild: The new `rightBracket` to replace the node's
  ///                   current `rightBracket`, if present.
  public func withRightBracket(
    _ newChild: TokenSyntax?) -> SubscriptExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBracket)
    return SubscriptExprSyntax(root: root, data: newData)
  }
  public var trailingClosure: ClosureExprSyntax? {
    let child = data.cachedChild(at: Cursor.trailingClosure)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ClosureExprSyntax
  }

  /// Returns a copy of the receiver with its `trailingClosure` replaced.
  /// - param newChild: The new `trailingClosure` to replace the node's
  ///                   current `trailingClosure`, if present.
  public func withTrailingClosure(
    _ newChild: ClosureExprSyntax?) -> SubscriptExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.closureExpr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingClosure)
    return SubscriptExprSyntax(root: root, data: newData)
  }

  /// Determines if two `SubscriptExprSyntax` nodes are equal to each other.
  public static func ==(lhs: SubscriptExprSyntax, rhs: SubscriptExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct OptionalChainingExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
    case questionMark
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `OptionalChainingExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> OptionalChainingExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return OptionalChainingExprSyntax(root: root, data: newData)
  }
  public var questionMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.questionMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `questionMark` replaced.
  /// - param newChild: The new `questionMark` to replace the node's
  ///                   current `questionMark`, if present.
  public func withQuestionMark(
    _ newChild: TokenSyntax?) -> OptionalChainingExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.questionMark)
    return OptionalChainingExprSyntax(root: root, data: newData)
  }

  /// Determines if two `OptionalChainingExprSyntax` nodes are equal to each other.
  public static func ==(lhs: OptionalChainingExprSyntax, rhs: OptionalChainingExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ForcedValueExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
    case exclamationMark
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ForcedValueExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ForcedValueExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ForcedValueExprSyntax(root: root, data: newData)
  }
  public var exclamationMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.exclamationMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `exclamationMark` replaced.
  /// - param newChild: The new `exclamationMark` to replace the node's
  ///                   current `exclamationMark`, if present.
  public func withExclamationMark(
    _ newChild: TokenSyntax?) -> ForcedValueExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.exclamationMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.exclamationMark)
    return ForcedValueExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ForcedValueExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ForcedValueExprSyntax, rhs: ForcedValueExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PostfixUnaryExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
    case operatorToken
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PostfixUnaryExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> PostfixUnaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return PostfixUnaryExprSyntax(root: root, data: newData)
  }
  public var operatorToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.operatorToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `operatorToken` replaced.
  /// - param newChild: The new `operatorToken` to replace the node's
  ///                   current `operatorToken`, if present.
  public func withOperatorToken(
    _ newChild: TokenSyntax?) -> PostfixUnaryExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixOperator(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.operatorToken)
    return PostfixUnaryExprSyntax(root: root, data: newData)
  }

  /// Determines if two `PostfixUnaryExprSyntax` nodes are equal to each other.
  public static func ==(lhs: PostfixUnaryExprSyntax, rhs: PostfixUnaryExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SpecializeExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
    case genericArgumentClause
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SpecializeExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> SpecializeExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return SpecializeExprSyntax(root: root, data: newData)
  }
  public var genericArgumentClause: GenericArgumentClauseSyntax {
    let child = data.cachedChild(at: Cursor.genericArgumentClause)
    return makeSyntax(root: _root, data: child!) as! GenericArgumentClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericArgumentClause` replaced.
  /// - param newChild: The new `genericArgumentClause` to replace the node's
  ///                   current `genericArgumentClause`, if present.
  public func withGenericArgumentClause(
    _ newChild: GenericArgumentClauseSyntax?) -> SpecializeExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericArgumentClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericArgumentClause)
    return SpecializeExprSyntax(root: root, data: newData)
  }

  /// Determines if two `SpecializeExprSyntax` nodes are equal to each other.
  public static func ==(lhs: SpecializeExprSyntax, rhs: SpecializeExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct StringSegmentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case content
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `StringSegmentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var content: TokenSyntax {
    let child = data.cachedChild(at: Cursor.content)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `content` replaced.
  /// - param newChild: The new `content` to replace the node's
  ///                   current `content`, if present.
  public func withContent(
    _ newChild: TokenSyntax?) -> StringSegmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.stringSegment(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.content)
    return StringSegmentSyntax(root: root, data: newData)
  }

  /// Determines if two `StringSegmentSyntax` nodes are equal to each other.
  public static func ==(lhs: StringSegmentSyntax, rhs: StringSegmentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ExpressionSegmentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case backslash
    case leftParen
    case expression
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ExpressionSegmentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var backslash: TokenSyntax {
    let child = data.cachedChild(at: Cursor.backslash)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `backslash` replaced.
  /// - param newChild: The new `backslash` to replace the node's
  ///                   current `backslash`, if present.
  public func withBackslash(
    _ newChild: TokenSyntax?) -> ExpressionSegmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.backslash)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.backslash)
    return ExpressionSegmentSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> ExpressionSegmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return ExpressionSegmentSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ExpressionSegmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ExpressionSegmentSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> ExpressionSegmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.stringInterpolationAnchor)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return ExpressionSegmentSyntax(root: root, data: newData)
  }

  /// Determines if two `ExpressionSegmentSyntax` nodes are equal to each other.
  public static func ==(lhs: ExpressionSegmentSyntax, rhs: ExpressionSegmentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct StringInterpolationExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case openQuote
    case segments
    case closeQuote
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `StringInterpolationExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var openQuote: TokenSyntax {
    let child = data.cachedChild(at: Cursor.openQuote)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `openQuote` replaced.
  /// - param newChild: The new `openQuote` to replace the node's
  ///                   current `openQuote`, if present.
  public func withOpenQuote(
    _ newChild: TokenSyntax?) -> StringInterpolationExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.stringQuote)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.openQuote)
    return StringInterpolationExprSyntax(root: root, data: newData)
  }
  public var segments: StringInterpolationSegmentsSyntax {
    let child = data.cachedChild(at: Cursor.segments)
    return makeSyntax(root: _root, data: child!) as! StringInterpolationSegmentsSyntax
  }

  /// Adds the provided `Segment` to the node's `segments`
  /// collection.
  /// - param element: The new `Segment` to add to the node's
  ///                  `segments` collection.
  /// - returns: A copy of the receiver with the provided `Segment`
  ///            appended to its `segments` collection.
  public func addSegment(_ element: Syntax) -> StringInterpolationExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.segments] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.stringInterpolationSegments,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.segments)
    return StringInterpolationExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `segments` replaced.
  /// - param newChild: The new `segments` to replace the node's
  ///                   current `segments`, if present.
  public func withSegments(
    _ newChild: StringInterpolationSegmentsSyntax?) -> StringInterpolationExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.stringInterpolationSegments)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.segments)
    return StringInterpolationExprSyntax(root: root, data: newData)
  }
  public var closeQuote: TokenSyntax {
    let child = data.cachedChild(at: Cursor.closeQuote)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `closeQuote` replaced.
  /// - param newChild: The new `closeQuote` to replace the node's
  ///                   current `closeQuote`, if present.
  public func withCloseQuote(
    _ newChild: TokenSyntax?) -> StringInterpolationExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.stringQuote)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.closeQuote)
    return StringInterpolationExprSyntax(root: root, data: newData)
  }

  /// Determines if two `StringInterpolationExprSyntax` nodes are equal to each other.
  public static func ==(lhs: StringInterpolationExprSyntax, rhs: StringInterpolationExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct KeyPathExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case backslash
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `KeyPathExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var backslash: TokenSyntax {
    let child = data.cachedChild(at: Cursor.backslash)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `backslash` replaced.
  /// - param newChild: The new `backslash` to replace the node's
  ///                   current `backslash`, if present.
  public func withBackslash(
    _ newChild: TokenSyntax?) -> KeyPathExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.backslash)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.backslash)
    return KeyPathExprSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> KeyPathExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return KeyPathExprSyntax(root: root, data: newData)
  }

  /// Determines if two `KeyPathExprSyntax` nodes are equal to each other.
  public static func ==(lhs: KeyPathExprSyntax, rhs: KeyPathExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ObjcNamePieceSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case dot
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ObjcNamePieceSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> ObjcNamePieceSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return ObjcNamePieceSyntax(root: root, data: newData)
  }
  public var dot: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.dot)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `dot` replaced.
  /// - param newChild: The new `dot` to replace the node's
  ///                   current `dot`, if present.
  public func withDot(
    _ newChild: TokenSyntax?) -> ObjcNamePieceSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.dot)
    return ObjcNamePieceSyntax(root: root, data: newData)
  }

  /// Determines if two `ObjcNamePieceSyntax` nodes are equal to each other.
  public static func ==(lhs: ObjcNamePieceSyntax, rhs: ObjcNamePieceSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ObjcKeyPathExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case keyPath
    case leftParen
    case name
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ObjcKeyPathExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var keyPath: TokenSyntax {
    let child = data.cachedChild(at: Cursor.keyPath)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `keyPath` replaced.
  /// - param newChild: The new `keyPath` to replace the node's
  ///                   current `keyPath`, if present.
  public func withKeyPath(
    _ newChild: TokenSyntax?) -> ObjcKeyPathExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundKeyPathKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.keyPath)
    return ObjcKeyPathExprSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> ObjcKeyPathExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return ObjcKeyPathExprSyntax(root: root, data: newData)
  }
  public var name: ObjcNameSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! ObjcNameSyntax
  }

  /// Adds the provided `ObjcNamePiece` to the node's `name`
  /// collection.
  /// - param element: The new `ObjcNamePiece` to add to the node's
  ///                  `name` collection.
  /// - returns: A copy of the receiver with the provided `ObjcNamePiece`
  ///            appended to its `name` collection.
  public func addObjcNamePiece(_ element: ObjcNamePieceSyntax) -> ObjcKeyPathExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.name] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.objcName,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.name)
    return ObjcKeyPathExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: ObjcNameSyntax?) -> ObjcKeyPathExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.objcName)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return ObjcKeyPathExprSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> ObjcKeyPathExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return ObjcKeyPathExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ObjcKeyPathExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ObjcKeyPathExprSyntax, rhs: ObjcKeyPathExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ObjcSelectorExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundSelector
    case leftParen
    case kind
    case colon
    case name
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ObjcSelectorExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundSelector: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundSelector)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundSelector` replaced.
  /// - param newChild: The new `poundSelector` to replace the node's
  ///                   current `poundSelector`, if present.
  public func withPoundSelector(
    _ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundSelectorKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundSelector)
    return ObjcSelectorExprSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return ObjcSelectorExprSyntax(root: root, data: newData)
  }
  public var kind: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.kind)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `kind` replaced.
  /// - param newChild: The new `kind` to replace the node's
  ///                   current `kind`, if present.
  public func withKind(
    _ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.contextualKeyword(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.kind)
    return ObjcSelectorExprSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return ObjcSelectorExprSyntax(root: root, data: newData)
  }
  public var name: ExprSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: ExprSyntax?) -> ObjcSelectorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return ObjcSelectorExprSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> ObjcSelectorExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return ObjcSelectorExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ObjcSelectorExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ObjcSelectorExprSyntax, rhs: ObjcSelectorExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct EditorPlaceholderExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case identifier
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `EditorPlaceholderExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> EditorPlaceholderExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return EditorPlaceholderExprSyntax(root: root, data: newData)
  }

  /// Determines if two `EditorPlaceholderExprSyntax` nodes are equal to each other.
  public static func ==(lhs: EditorPlaceholderExprSyntax, rhs: EditorPlaceholderExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ObjectLiteralExprSyntax: ExprSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case identifier
    case leftParen
    case arguments
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ObjectLiteralExprSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> ObjectLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundColorLiteralKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return ObjectLiteralExprSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> ObjectLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return ObjectLiteralExprSyntax(root: root, data: newData)
  }
  public var arguments: FunctionCallArgumentListSyntax {
    let child = data.cachedChild(at: Cursor.arguments)
    return makeSyntax(root: _root, data: child!) as! FunctionCallArgumentListSyntax
  }

  /// Adds the provided `FunctionCallArgument` to the node's `arguments`
  /// collection.
  /// - param element: The new `FunctionCallArgument` to add to the node's
  ///                  `arguments` collection.
  /// - returns: A copy of the receiver with the provided `FunctionCallArgument`
  ///            appended to its `arguments` collection.
  public func addFunctionCallArgument(_ element: FunctionCallArgumentSyntax) -> ObjectLiteralExprSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.arguments] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.functionCallArgumentList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.arguments)
    return ObjectLiteralExprSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `arguments` replaced.
  /// - param newChild: The new `arguments` to replace the node's
  ///                   current `arguments`, if present.
  public func withArguments(
    _ newChild: FunctionCallArgumentListSyntax?) -> ObjectLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.functionCallArgumentList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arguments)
    return ObjectLiteralExprSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> ObjectLiteralExprSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return ObjectLiteralExprSyntax(root: root, data: newData)
  }

  /// Determines if two `ObjectLiteralExprSyntax` nodes are equal to each other.
  public static func ==(lhs: ObjectLiteralExprSyntax, rhs: ObjectLiteralExprSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TypeInitializerClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case equal
    case value
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TypeInitializerClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var equal: TokenSyntax {
    let child = data.cachedChild(at: Cursor.equal)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `equal` replaced.
  /// - param newChild: The new `equal` to replace the node's
  ///                   current `equal`, if present.
  public func withEqual(
    _ newChild: TokenSyntax?) -> TypeInitializerClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.equal)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.equal)
    return TypeInitializerClauseSyntax(root: root, data: newData)
  }
  public var value: TypeSyntax {
    let child = data.cachedChild(at: Cursor.value)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `value` replaced.
  /// - param newChild: The new `value` to replace the node's
  ///                   current `value`, if present.
  public func withValue(
    _ newChild: TypeSyntax?) -> TypeInitializerClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.value)
    return TypeInitializerClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `TypeInitializerClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: TypeInitializerClauseSyntax, rhs: TypeInitializerClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TypealiasDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case typealiasKeyword
    case identifier
    case genericParameterClause
    case initializer
    case genericWhereClause
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TypealiasDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> TypealiasDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return TypealiasDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return TypealiasDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> TypealiasDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return TypealiasDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return TypealiasDeclSyntax(root: root, data: newData)
  }
  public var typealiasKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.typealiasKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `typealiasKeyword` replaced.
  /// - param newChild: The new `typealiasKeyword` to replace the node's
  ///                   current `typealiasKeyword`, if present.
  public func withTypealiasKeyword(
    _ newChild: TokenSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.typealiasKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typealiasKeyword)
    return TypealiasDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return TypealiasDeclSyntax(root: root, data: newData)
  }
  public var genericParameterClause: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameterClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameterClause` replaced.
  /// - param newChild: The new `genericParameterClause` to replace the node's
  ///                   current `genericParameterClause`, if present.
  public func withGenericParameterClause(
    _ newChild: GenericParameterClauseSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterClause)
    return TypealiasDeclSyntax(root: root, data: newData)
  }
  public var initializer: TypeInitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.initializer)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `initializer` replaced.
  /// - param newChild: The new `initializer` to replace the node's
  ///                   current `initializer`, if present.
  public func withInitializer(
    _ newChild: TypeInitializerClauseSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInitializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initializer)
    return TypealiasDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> TypealiasDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return TypealiasDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `TypealiasDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: TypealiasDeclSyntax, rhs: TypealiasDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AssociatedtypeDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case associatedtypeKeyword
    case identifier
    case inheritanceClause
    case initializer
    case genericWhereClause
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AssociatedtypeDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> AssociatedtypeDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> AssociatedtypeDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }
  public var associatedtypeKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.associatedtypeKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `associatedtypeKeyword` replaced.
  /// - param newChild: The new `associatedtypeKeyword` to replace the node's
  ///                   current `associatedtypeKeyword`, if present.
  public func withAssociatedtypeKeyword(
    _ newChild: TokenSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.associatedtypeKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.associatedtypeKeyword)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }
  public var inheritanceClause: TypeInheritanceClauseSyntax? {
    let child = data.cachedChild(at: Cursor.inheritanceClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInheritanceClauseSyntax
  }

  /// Returns a copy of the receiver with its `inheritanceClause` replaced.
  /// - param newChild: The new `inheritanceClause` to replace the node's
  ///                   current `inheritanceClause`, if present.
  public func withInheritanceClause(
    _ newChild: TypeInheritanceClauseSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInheritanceClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritanceClause)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }
  public var initializer: TypeInitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.initializer)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `initializer` replaced.
  /// - param newChild: The new `initializer` to replace the node's
  ///                   current `initializer`, if present.
  public func withInitializer(
    _ newChild: TypeInitializerClauseSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInitializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initializer)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> AssociatedtypeDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return AssociatedtypeDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `AssociatedtypeDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: AssociatedtypeDeclSyntax, rhs: AssociatedtypeDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ParameterClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case parameterList
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ParameterClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> ParameterClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return ParameterClauseSyntax(root: root, data: newData)
  }
  public var parameterList: FunctionParameterListSyntax {
    let child = data.cachedChild(at: Cursor.parameterList)
    return makeSyntax(root: _root, data: child!) as! FunctionParameterListSyntax
  }

  /// Adds the provided `FunctionParameter` to the node's `parameterList`
  /// collection.
  /// - param element: The new `FunctionParameter` to add to the node's
  ///                  `parameterList` collection.
  /// - returns: A copy of the receiver with the provided `FunctionParameter`
  ///            appended to its `parameterList` collection.
  public func addFunctionParameter(_ element: FunctionParameterSyntax) -> ParameterClauseSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.parameterList] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.functionParameterList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.parameterList)
    return ParameterClauseSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `parameterList` replaced.
  /// - param newChild: The new `parameterList` to replace the node's
  ///                   current `parameterList`, if present.
  public func withParameterList(
    _ newChild: FunctionParameterListSyntax?) -> ParameterClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.functionParameterList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.parameterList)
    return ParameterClauseSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> ParameterClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return ParameterClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `ParameterClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: ParameterClauseSyntax, rhs: ParameterClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ReturnClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case arrow
    case returnType
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ReturnClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var arrow: TokenSyntax {
    let child = data.cachedChild(at: Cursor.arrow)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `arrow` replaced.
  /// - param newChild: The new `arrow` to replace the node's
  ///                   current `arrow`, if present.
  public func withArrow(
    _ newChild: TokenSyntax?) -> ReturnClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.arrow)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arrow)
    return ReturnClauseSyntax(root: root, data: newData)
  }
  public var returnType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.returnType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `returnType` replaced.
  /// - param newChild: The new `returnType` to replace the node's
  ///                   current `returnType`, if present.
  public func withReturnType(
    _ newChild: TypeSyntax?) -> ReturnClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.returnType)
    return ReturnClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `ReturnClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: ReturnClauseSyntax, rhs: ReturnClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FunctionSignatureSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case input
    case throwsOrRethrowsKeyword
    case output
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionSignatureSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var input: ParameterClauseSyntax {
    let child = data.cachedChild(at: Cursor.input)
    return makeSyntax(root: _root, data: child!) as! ParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `input` replaced.
  /// - param newChild: The new `input` to replace the node's
  ///                   current `input`, if present.
  public func withInput(
    _ newChild: ParameterClauseSyntax?) -> FunctionSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.parameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.input)
    return FunctionSignatureSyntax(root: root, data: newData)
  }
  public var throwsOrRethrowsKeyword: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.throwsOrRethrowsKeyword)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `throwsOrRethrowsKeyword` replaced.
  /// - param newChild: The new `throwsOrRethrowsKeyword` to replace the node's
  ///                   current `throwsOrRethrowsKeyword`, if present.
  public func withThrowsOrRethrowsKeyword(
    _ newChild: TokenSyntax?) -> FunctionSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.throwsKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.throwsOrRethrowsKeyword)
    return FunctionSignatureSyntax(root: root, data: newData)
  }
  public var output: ReturnClauseSyntax? {
    let child = data.cachedChild(at: Cursor.output)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ReturnClauseSyntax
  }

  /// Returns a copy of the receiver with its `output` replaced.
  /// - param newChild: The new `output` to replace the node's
  ///                   current `output`, if present.
  public func withOutput(
    _ newChild: ReturnClauseSyntax?) -> FunctionSignatureSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.returnClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.output)
    return FunctionSignatureSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionSignatureSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionSignatureSyntax, rhs: FunctionSignatureSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IfConfigClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundKeyword
    case condition
    case elements
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IfConfigClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundKeyword` replaced.
  /// - param newChild: The new `poundKeyword` to replace the node's
  ///                   current `poundKeyword`, if present.
  public func withPoundKeyword(
    _ newChild: TokenSyntax?) -> IfConfigClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundIfKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundKeyword)
    return IfConfigClauseSyntax(root: root, data: newData)
  }
  public var condition: ExprSyntax? {
    let child = data.cachedChild(at: Cursor.condition)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ExprSyntax
  }

  /// Returns a copy of the receiver with its `condition` replaced.
  /// - param newChild: The new `condition` to replace the node's
  ///                   current `condition`, if present.
  public func withCondition(
    _ newChild: ExprSyntax?) -> IfConfigClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.condition)
    return IfConfigClauseSyntax(root: root, data: newData)
  }
  public var elements: Syntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: Syntax?) -> IfConfigClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return IfConfigClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `IfConfigClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: IfConfigClauseSyntax, rhs: IfConfigClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IfConfigDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case clauses
    case poundEndif
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IfConfigDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var clauses: IfConfigClauseListSyntax {
    let child = data.cachedChild(at: Cursor.clauses)
    return makeSyntax(root: _root, data: child!) as! IfConfigClauseListSyntax
  }

  /// Adds the provided `IfConfigClause` to the node's `clauses`
  /// collection.
  /// - param element: The new `IfConfigClause` to add to the node's
  ///                  `clauses` collection.
  /// - returns: A copy of the receiver with the provided `IfConfigClause`
  ///            appended to its `clauses` collection.
  public func addIfConfigClause(_ element: IfConfigClauseSyntax) -> IfConfigDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.clauses] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.ifConfigClauseList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.clauses)
    return IfConfigDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `clauses` replaced.
  /// - param newChild: The new `clauses` to replace the node's
  ///                   current `clauses`, if present.
  public func withClauses(
    _ newChild: IfConfigClauseListSyntax?) -> IfConfigDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.ifConfigClauseList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.clauses)
    return IfConfigDeclSyntax(root: root, data: newData)
  }
  public var poundEndif: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundEndif)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundEndif` replaced.
  /// - param newChild: The new `poundEndif` to replace the node's
  ///                   current `poundEndif`, if present.
  public func withPoundEndif(
    _ newChild: TokenSyntax?) -> IfConfigDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundEndifKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundEndif)
    return IfConfigDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `IfConfigDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: IfConfigDeclSyntax, rhs: IfConfigDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundErrorDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundError
    case leftParen
    case message
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundErrorDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundError: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundError)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundError` replaced.
  /// - param newChild: The new `poundError` to replace the node's
  ///                   current `poundError`, if present.
  public func withPoundError(
    _ newChild: TokenSyntax?) -> PoundErrorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundError)
    return PoundErrorDeclSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> PoundErrorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return PoundErrorDeclSyntax(root: root, data: newData)
  }
  public var message: StringLiteralExprSyntax {
    let child = data.cachedChild(at: Cursor.message)
    return makeSyntax(root: _root, data: child!) as! StringLiteralExprSyntax
  }

  /// Returns a copy of the receiver with its `message` replaced.
  /// - param newChild: The new `message` to replace the node's
  ///                   current `message`, if present.
  public func withMessage(
    _ newChild: StringLiteralExprSyntax?) -> PoundErrorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.stringLiteralExpr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.message)
    return PoundErrorDeclSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> PoundErrorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return PoundErrorDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundErrorDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundErrorDeclSyntax, rhs: PoundErrorDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PoundWarningDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundWarning
    case leftParen
    case message
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PoundWarningDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundWarning: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundWarning)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundWarning` replaced.
  /// - param newChild: The new `poundWarning` to replace the node's
  ///                   current `poundWarning`, if present.
  public func withPoundWarning(
    _ newChild: TokenSyntax?) -> PoundWarningDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundWarning)
    return PoundWarningDeclSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> PoundWarningDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return PoundWarningDeclSyntax(root: root, data: newData)
  }
  public var message: StringLiteralExprSyntax {
    let child = data.cachedChild(at: Cursor.message)
    return makeSyntax(root: _root, data: child!) as! StringLiteralExprSyntax
  }

  /// Returns a copy of the receiver with its `message` replaced.
  /// - param newChild: The new `message` to replace the node's
  ///                   current `message`, if present.
  public func withMessage(
    _ newChild: StringLiteralExprSyntax?) -> PoundWarningDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.stringLiteralExpr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.message)
    return PoundWarningDeclSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> PoundWarningDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return PoundWarningDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `PoundWarningDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: PoundWarningDeclSyntax, rhs: PoundWarningDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DeclModifierSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case detail
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DeclModifierSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> DeclModifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return DeclModifierSyntax(root: root, data: newData)
  }
  public var detail: TokenListSyntax? {
    let child = data.cachedChild(at: Cursor.detail)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenListSyntax
  }

  /// Adds the provided `Token` to the node's `detail`
  /// collection.
  /// - param element: The new `Token` to add to the node's
  ///                  `detail` collection.
  /// - returns: A copy of the receiver with the provided `Token`
  ///            appended to its `detail` collection.
  public func addToken(_ element: TokenSyntax) -> DeclModifierSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.detail] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tokenList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.detail)
    return DeclModifierSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `detail` replaced.
  /// - param newChild: The new `detail` to replace the node's
  ///                   current `detail`, if present.
  public func withDetail(
    _ newChild: TokenListSyntax?) -> DeclModifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.detail)
    return DeclModifierSyntax(root: root, data: newData)
  }

  /// Determines if two `DeclModifierSyntax` nodes are equal to each other.
  public static func ==(lhs: DeclModifierSyntax, rhs: DeclModifierSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct InheritedTypeSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case typeName
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `InheritedTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var typeName: TypeSyntax {
    let child = data.cachedChild(at: Cursor.typeName)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `typeName` replaced.
  /// - param newChild: The new `typeName` to replace the node's
  ///                   current `typeName`, if present.
  public func withTypeName(
    _ newChild: TypeSyntax?) -> InheritedTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeName)
    return InheritedTypeSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> InheritedTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return InheritedTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `InheritedTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: InheritedTypeSyntax, rhs: InheritedTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TypeInheritanceClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case colon
    case inheritedTypeCollection
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TypeInheritanceClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> TypeInheritanceClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return TypeInheritanceClauseSyntax(root: root, data: newData)
  }
  public var inheritedTypeCollection: InheritedTypeListSyntax {
    let child = data.cachedChild(at: Cursor.inheritedTypeCollection)
    return makeSyntax(root: _root, data: child!) as! InheritedTypeListSyntax
  }

  /// Adds the provided `InheritedType` to the node's `inheritedTypeCollection`
  /// collection.
  /// - param element: The new `InheritedType` to add to the node's
  ///                  `inheritedTypeCollection` collection.
  /// - returns: A copy of the receiver with the provided `InheritedType`
  ///            appended to its `inheritedTypeCollection` collection.
  public func addInheritedType(_ element: InheritedTypeSyntax) -> TypeInheritanceClauseSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.inheritedTypeCollection] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.inheritedTypeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.inheritedTypeCollection)
    return TypeInheritanceClauseSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `inheritedTypeCollection` replaced.
  /// - param newChild: The new `inheritedTypeCollection` to replace the node's
  ///                   current `inheritedTypeCollection`, if present.
  public func withInheritedTypeCollection(
    _ newChild: InheritedTypeListSyntax?) -> TypeInheritanceClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.inheritedTypeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritedTypeCollection)
    return TypeInheritanceClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `TypeInheritanceClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: TypeInheritanceClauseSyntax, rhs: TypeInheritanceClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ClassDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case classKeyword
    case identifier
    case genericParameterClause
    case inheritanceClause
    case genericWhereClause
    case members
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ClassDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> ClassDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return ClassDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> ClassDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return ClassDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var classKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.classKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `classKeyword` replaced.
  /// - param newChild: The new `classKeyword` to replace the node's
  ///                   current `classKeyword`, if present.
  public func withClassKeyword(
    _ newChild: TokenSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.classKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.classKeyword)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var genericParameterClause: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameterClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameterClause` replaced.
  /// - param newChild: The new `genericParameterClause` to replace the node's
  ///                   current `genericParameterClause`, if present.
  public func withGenericParameterClause(
    _ newChild: GenericParameterClauseSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterClause)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var inheritanceClause: TypeInheritanceClauseSyntax? {
    let child = data.cachedChild(at: Cursor.inheritanceClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInheritanceClauseSyntax
  }

  /// Returns a copy of the receiver with its `inheritanceClause` replaced.
  /// - param newChild: The new `inheritanceClause` to replace the node's
  ///                   current `inheritanceClause`, if present.
  public func withInheritanceClause(
    _ newChild: TypeInheritanceClauseSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInheritanceClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritanceClause)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return ClassDeclSyntax(root: root, data: newData)
  }
  public var members: MemberDeclBlockSyntax {
    let child = data.cachedChild(at: Cursor.members)
    return makeSyntax(root: _root, data: child!) as! MemberDeclBlockSyntax
  }

  /// Returns a copy of the receiver with its `members` replaced.
  /// - param newChild: The new `members` to replace the node's
  ///                   current `members`, if present.
  public func withMembers(
    _ newChild: MemberDeclBlockSyntax?) -> ClassDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.memberDeclBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.members)
    return ClassDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `ClassDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: ClassDeclSyntax, rhs: ClassDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct StructDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case structKeyword
    case identifier
    case genericParameterClause
    case inheritanceClause
    case genericWhereClause
    case members
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `StructDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> StructDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return StructDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> StructDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return StructDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var structKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.structKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `structKeyword` replaced.
  /// - param newChild: The new `structKeyword` to replace the node's
  ///                   current `structKeyword`, if present.
  public func withStructKeyword(
    _ newChild: TokenSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.structKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.structKeyword)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var genericParameterClause: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameterClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameterClause` replaced.
  /// - param newChild: The new `genericParameterClause` to replace the node's
  ///                   current `genericParameterClause`, if present.
  public func withGenericParameterClause(
    _ newChild: GenericParameterClauseSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterClause)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var inheritanceClause: TypeInheritanceClauseSyntax? {
    let child = data.cachedChild(at: Cursor.inheritanceClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInheritanceClauseSyntax
  }

  /// Returns a copy of the receiver with its `inheritanceClause` replaced.
  /// - param newChild: The new `inheritanceClause` to replace the node's
  ///                   current `inheritanceClause`, if present.
  public func withInheritanceClause(
    _ newChild: TypeInheritanceClauseSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInheritanceClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritanceClause)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return StructDeclSyntax(root: root, data: newData)
  }
  public var members: MemberDeclBlockSyntax {
    let child = data.cachedChild(at: Cursor.members)
    return makeSyntax(root: _root, data: child!) as! MemberDeclBlockSyntax
  }

  /// Returns a copy of the receiver with its `members` replaced.
  /// - param newChild: The new `members` to replace the node's
  ///                   current `members`, if present.
  public func withMembers(
    _ newChild: MemberDeclBlockSyntax?) -> StructDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.memberDeclBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.members)
    return StructDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `StructDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: StructDeclSyntax, rhs: StructDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ProtocolDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case protocolKeyword
    case identifier
    case inheritanceClause
    case genericWhereClause
    case members
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ProtocolDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> ProtocolDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return ProtocolDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return ProtocolDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> ProtocolDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return ProtocolDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return ProtocolDeclSyntax(root: root, data: newData)
  }
  public var protocolKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.protocolKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `protocolKeyword` replaced.
  /// - param newChild: The new `protocolKeyword` to replace the node's
  ///                   current `protocolKeyword`, if present.
  public func withProtocolKeyword(
    _ newChild: TokenSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.protocolKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.protocolKeyword)
    return ProtocolDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return ProtocolDeclSyntax(root: root, data: newData)
  }
  public var inheritanceClause: TypeInheritanceClauseSyntax? {
    let child = data.cachedChild(at: Cursor.inheritanceClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInheritanceClauseSyntax
  }

  /// Returns a copy of the receiver with its `inheritanceClause` replaced.
  /// - param newChild: The new `inheritanceClause` to replace the node's
  ///                   current `inheritanceClause`, if present.
  public func withInheritanceClause(
    _ newChild: TypeInheritanceClauseSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInheritanceClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritanceClause)
    return ProtocolDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return ProtocolDeclSyntax(root: root, data: newData)
  }
  public var members: MemberDeclBlockSyntax {
    let child = data.cachedChild(at: Cursor.members)
    return makeSyntax(root: _root, data: child!) as! MemberDeclBlockSyntax
  }

  /// Returns a copy of the receiver with its `members` replaced.
  /// - param newChild: The new `members` to replace the node's
  ///                   current `members`, if present.
  public func withMembers(
    _ newChild: MemberDeclBlockSyntax?) -> ProtocolDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.memberDeclBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.members)
    return ProtocolDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `ProtocolDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: ProtocolDeclSyntax, rhs: ProtocolDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ExtensionDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case extensionKeyword
    case extendedType
    case inheritanceClause
    case genericWhereClause
    case members
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ExtensionDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> ExtensionDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return ExtensionDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return ExtensionDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> ExtensionDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return ExtensionDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return ExtensionDeclSyntax(root: root, data: newData)
  }
  public var extensionKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.extensionKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `extensionKeyword` replaced.
  /// - param newChild: The new `extensionKeyword` to replace the node's
  ///                   current `extensionKeyword`, if present.
  public func withExtensionKeyword(
    _ newChild: TokenSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.extensionKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.extensionKeyword)
    return ExtensionDeclSyntax(root: root, data: newData)
  }
  public var extendedType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.extendedType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `extendedType` replaced.
  /// - param newChild: The new `extendedType` to replace the node's
  ///                   current `extendedType`, if present.
  public func withExtendedType(
    _ newChild: TypeSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.extendedType)
    return ExtensionDeclSyntax(root: root, data: newData)
  }
  public var inheritanceClause: TypeInheritanceClauseSyntax? {
    let child = data.cachedChild(at: Cursor.inheritanceClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInheritanceClauseSyntax
  }

  /// Returns a copy of the receiver with its `inheritanceClause` replaced.
  /// - param newChild: The new `inheritanceClause` to replace the node's
  ///                   current `inheritanceClause`, if present.
  public func withInheritanceClause(
    _ newChild: TypeInheritanceClauseSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInheritanceClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritanceClause)
    return ExtensionDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return ExtensionDeclSyntax(root: root, data: newData)
  }
  public var members: MemberDeclBlockSyntax {
    let child = data.cachedChild(at: Cursor.members)
    return makeSyntax(root: _root, data: child!) as! MemberDeclBlockSyntax
  }

  /// Returns a copy of the receiver with its `members` replaced.
  /// - param newChild: The new `members` to replace the node's
  ///                   current `members`, if present.
  public func withMembers(
    _ newChild: MemberDeclBlockSyntax?) -> ExtensionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.memberDeclBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.members)
    return ExtensionDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `ExtensionDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: ExtensionDeclSyntax, rhs: ExtensionDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct MemberDeclBlockSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftBrace
    case members
    case rightBrace
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `MemberDeclBlockSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBrace` replaced.
  /// - param newChild: The new `leftBrace` to replace the node's
  ///                   current `leftBrace`, if present.
  public func withLeftBrace(
    _ newChild: TokenSyntax?) -> MemberDeclBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBrace)
    return MemberDeclBlockSyntax(root: root, data: newData)
  }
  public var members: DeclListSyntax {
    let child = data.cachedChild(at: Cursor.members)
    return makeSyntax(root: _root, data: child!) as! DeclListSyntax
  }

  /// Adds the provided `Decl` to the node's `members`
  /// collection.
  /// - param element: The new `Decl` to add to the node's
  ///                  `members` collection.
  /// - returns: A copy of the receiver with the provided `Decl`
  ///            appended to its `members` collection.
  public func addDecl(_ element: DeclSyntax) -> MemberDeclBlockSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.members] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.declList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.members)
    return MemberDeclBlockSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `members` replaced.
  /// - param newChild: The new `members` to replace the node's
  ///                   current `members`, if present.
  public func withMembers(
    _ newChild: DeclListSyntax?) -> MemberDeclBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.declList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.members)
    return MemberDeclBlockSyntax(root: root, data: newData)
  }
  public var rightBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBrace` replaced.
  /// - param newChild: The new `rightBrace` to replace the node's
  ///                   current `rightBrace`, if present.
  public func withRightBrace(
    _ newChild: TokenSyntax?) -> MemberDeclBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBrace)
    return MemberDeclBlockSyntax(root: root, data: newData)
  }

  /// Determines if two `MemberDeclBlockSyntax` nodes are equal to each other.
  public static func ==(lhs: MemberDeclBlockSyntax, rhs: MemberDeclBlockSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SourceFileSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case statements
    case eofToken
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SourceFileSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var statements: CodeBlockItemListSyntax {
    let child = data.cachedChild(at: Cursor.statements)
    return makeSyntax(root: _root, data: child!) as! CodeBlockItemListSyntax
  }

  /// Adds the provided `CodeBlockItem` to the node's `statements`
  /// collection.
  /// - param element: The new `CodeBlockItem` to add to the node's
  ///                  `statements` collection.
  /// - returns: A copy of the receiver with the provided `CodeBlockItem`
  ///            appended to its `statements` collection.
  public func addCodeBlockItem(_ element: CodeBlockItemSyntax) -> SourceFileSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.statements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.codeBlockItemList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.statements)
    return SourceFileSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `statements` replaced.
  /// - param newChild: The new `statements` to replace the node's
  ///                   current `statements`, if present.
  public func withStatements(
    _ newChild: CodeBlockItemListSyntax?) -> SourceFileSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlockItemList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.statements)
    return SourceFileSyntax(root: root, data: newData)
  }
  public var eofToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.eofToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `eofToken` replaced.
  /// - param newChild: The new `eofToken` to replace the node's
  ///                   current `eofToken`, if present.
  public func withEOFToken(
    _ newChild: TokenSyntax?) -> SourceFileSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.eofToken)
    return SourceFileSyntax(root: root, data: newData)
  }

  /// Determines if two `SourceFileSyntax` nodes are equal to each other.
  public static func ==(lhs: SourceFileSyntax, rhs: SourceFileSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct InitializerClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case equal
    case value
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `InitializerClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var equal: TokenSyntax {
    let child = data.cachedChild(at: Cursor.equal)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `equal` replaced.
  /// - param newChild: The new `equal` to replace the node's
  ///                   current `equal`, if present.
  public func withEqual(
    _ newChild: TokenSyntax?) -> InitializerClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.equal)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.equal)
    return InitializerClauseSyntax(root: root, data: newData)
  }
  public var value: ExprSyntax {
    let child = data.cachedChild(at: Cursor.value)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `value` replaced.
  /// - param newChild: The new `value` to replace the node's
  ///                   current `value`, if present.
  public func withValue(
    _ newChild: ExprSyntax?) -> InitializerClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.value)
    return InitializerClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `InitializerClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: InitializerClauseSyntax, rhs: InitializerClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FunctionParameterSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case firstName
    case secondName
    case colon
    case type
    case ellipsis
    case defaultArgument
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionParameterSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> FunctionParameterSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return FunctionParameterSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var firstName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.firstName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `firstName` replaced.
  /// - param newChild: The new `firstName` to replace the node's
  ///                   current `firstName`, if present.
  public func withFirstName(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.firstName)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var secondName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.secondName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `secondName` replaced.
  /// - param newChild: The new `secondName` to replace the node's
  ///                   current `secondName`, if present.
  public func withSecondName(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.secondName)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var type: TypeSyntax? {
    let child = data.cachedChild(at: Cursor.type)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var ellipsis: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.ellipsis)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `ellipsis` replaced.
  /// - param newChild: The new `ellipsis` to replace the node's
  ///                   current `ellipsis`, if present.
  public func withEllipsis(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ellipsis)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var defaultArgument: InitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.defaultArgument)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `defaultArgument` replaced.
  /// - param newChild: The new `defaultArgument` to replace the node's
  ///                   current `defaultArgument`, if present.
  public func withDefaultArgument(
    _ newChild: InitializerClauseSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.defaultArgument)
    return FunctionParameterSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> FunctionParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return FunctionParameterSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionParameterSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionParameterSyntax, rhs: FunctionParameterSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FunctionDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case funcKeyword
    case identifier
    case genericParameterClause
    case signature
    case genericWhereClause
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> FunctionDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return FunctionDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> FunctionDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return FunctionDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var funcKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.funcKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `funcKeyword` replaced.
  /// - param newChild: The new `funcKeyword` to replace the node's
  ///                   current `funcKeyword`, if present.
  public func withFuncKeyword(
    _ newChild: TokenSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.funcKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.funcKeyword)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var genericParameterClause: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameterClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameterClause` replaced.
  /// - param newChild: The new `genericParameterClause` to replace the node's
  ///                   current `genericParameterClause`, if present.
  public func withGenericParameterClause(
    _ newChild: GenericParameterClauseSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterClause)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var signature: FunctionSignatureSyntax {
    let child = data.cachedChild(at: Cursor.signature)
    return makeSyntax(root: _root, data: child!) as! FunctionSignatureSyntax
  }

  /// Returns a copy of the receiver with its `signature` replaced.
  /// - param newChild: The new `signature` to replace the node's
  ///                   current `signature`, if present.
  public func withSignature(
    _ newChild: FunctionSignatureSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.functionSignature)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.signature)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return FunctionDeclSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax? {
    let child = data.cachedChild(at: Cursor.body)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> FunctionDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return FunctionDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionDeclSyntax, rhs: FunctionDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct InitializerDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case initKeyword
    case optionalMark
    case genericParameterClause
    case parameters
    case throwsOrRethrowsKeyword
    case genericWhereClause
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `InitializerDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> InitializerDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return InitializerDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> InitializerDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return InitializerDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var initKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.initKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `initKeyword` replaced.
  /// - param newChild: The new `initKeyword` to replace the node's
  ///                   current `initKeyword`, if present.
  public func withInitKeyword(
    _ newChild: TokenSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.initKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initKeyword)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var optionalMark: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.optionalMark)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `optionalMark` replaced.
  /// - param newChild: The new `optionalMark` to replace the node's
  ///                   current `optionalMark`, if present.
  public func withOptionalMark(
    _ newChild: TokenSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.optionalMark)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var genericParameterClause: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameterClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameterClause` replaced.
  /// - param newChild: The new `genericParameterClause` to replace the node's
  ///                   current `genericParameterClause`, if present.
  public func withGenericParameterClause(
    _ newChild: GenericParameterClauseSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterClause)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var parameters: ParameterClauseSyntax {
    let child = data.cachedChild(at: Cursor.parameters)
    return makeSyntax(root: _root, data: child!) as! ParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `parameters` replaced.
  /// - param newChild: The new `parameters` to replace the node's
  ///                   current `parameters`, if present.
  public func withParameters(
    _ newChild: ParameterClauseSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.parameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.parameters)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var throwsOrRethrowsKeyword: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.throwsOrRethrowsKeyword)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `throwsOrRethrowsKeyword` replaced.
  /// - param newChild: The new `throwsOrRethrowsKeyword` to replace the node's
  ///                   current `throwsOrRethrowsKeyword`, if present.
  public func withThrowsOrRethrowsKeyword(
    _ newChild: TokenSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.throwsKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.throwsOrRethrowsKeyword)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return InitializerDeclSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax? {
    let child = data.cachedChild(at: Cursor.body)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> InitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return InitializerDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `InitializerDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: InitializerDeclSyntax, rhs: InitializerDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DeinitializerDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case deinitKeyword
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DeinitializerDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> DeinitializerDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return DeinitializerDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> DeinitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return DeinitializerDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> DeinitializerDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return DeinitializerDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> DeinitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return DeinitializerDeclSyntax(root: root, data: newData)
  }
  public var deinitKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.deinitKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `deinitKeyword` replaced.
  /// - param newChild: The new `deinitKeyword` to replace the node's
  ///                   current `deinitKeyword`, if present.
  public func withDeinitKeyword(
    _ newChild: TokenSyntax?) -> DeinitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.deinitKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.deinitKeyword)
    return DeinitializerDeclSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> DeinitializerDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return DeinitializerDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `DeinitializerDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: DeinitializerDeclSyntax, rhs: DeinitializerDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SubscriptDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case subscriptKeyword
    case genericParameterClause
    case indices
    case result
    case genericWhereClause
    case accessor
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SubscriptDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> SubscriptDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return SubscriptDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> SubscriptDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return SubscriptDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var subscriptKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.subscriptKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `subscriptKeyword` replaced.
  /// - param newChild: The new `subscriptKeyword` to replace the node's
  ///                   current `subscriptKeyword`, if present.
  public func withSubscriptKeyword(
    _ newChild: TokenSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.subscriptKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.subscriptKeyword)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var genericParameterClause: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameterClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameterClause` replaced.
  /// - param newChild: The new `genericParameterClause` to replace the node's
  ///                   current `genericParameterClause`, if present.
  public func withGenericParameterClause(
    _ newChild: GenericParameterClauseSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterClause)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var indices: ParameterClauseSyntax {
    let child = data.cachedChild(at: Cursor.indices)
    return makeSyntax(root: _root, data: child!) as! ParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `indices` replaced.
  /// - param newChild: The new `indices` to replace the node's
  ///                   current `indices`, if present.
  public func withIndices(
    _ newChild: ParameterClauseSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.parameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.indices)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var result: ReturnClauseSyntax {
    let child = data.cachedChild(at: Cursor.result)
    return makeSyntax(root: _root, data: child!) as! ReturnClauseSyntax
  }

  /// Returns a copy of the receiver with its `result` replaced.
  /// - param newChild: The new `result` to replace the node's
  ///                   current `result`, if present.
  public func withResult(
    _ newChild: ReturnClauseSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.returnClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.result)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return SubscriptDeclSyntax(root: root, data: newData)
  }
  public var accessor: AccessorBlockSyntax? {
    let child = data.cachedChild(at: Cursor.accessor)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AccessorBlockSyntax
  }

  /// Returns a copy of the receiver with its `accessor` replaced.
  /// - param newChild: The new `accessor` to replace the node's
  ///                   current `accessor`, if present.
  public func withAccessor(
    _ newChild: AccessorBlockSyntax?) -> SubscriptDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.accessorBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.accessor)
    return SubscriptDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `SubscriptDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: SubscriptDeclSyntax, rhs: SubscriptDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AccessLevelModifierSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case leftParen
    case modifier
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AccessLevelModifierSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> AccessLevelModifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return AccessLevelModifierSyntax(root: root, data: newData)
  }
  public var leftParen: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.leftParen)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> AccessLevelModifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return AccessLevelModifierSyntax(root: root, data: newData)
  }
  public var modifier: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.modifier)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `modifier` replaced.
  /// - param newChild: The new `modifier` to replace the node's
  ///                   current `modifier`, if present.
  public func withModifier(
    _ newChild: TokenSyntax?) -> AccessLevelModifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifier)
    return AccessLevelModifierSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.rightParen)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> AccessLevelModifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return AccessLevelModifierSyntax(root: root, data: newData)
  }

  /// Determines if two `AccessLevelModifierSyntax` nodes are equal to each other.
  public static func ==(lhs: AccessLevelModifierSyntax, rhs: AccessLevelModifierSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AccessPathComponentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case trailingDot
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AccessPathComponentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> AccessPathComponentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return AccessPathComponentSyntax(root: root, data: newData)
  }
  public var trailingDot: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingDot)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingDot` replaced.
  /// - param newChild: The new `trailingDot` to replace the node's
  ///                   current `trailingDot`, if present.
  public func withTrailingDot(
    _ newChild: TokenSyntax?) -> AccessPathComponentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingDot)
    return AccessPathComponentSyntax(root: root, data: newData)
  }

  /// Determines if two `AccessPathComponentSyntax` nodes are equal to each other.
  public static func ==(lhs: AccessPathComponentSyntax, rhs: AccessPathComponentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ImportDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case importTok
    case importKind
    case path
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ImportDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> ImportDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return ImportDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> ImportDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return ImportDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> ImportDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return ImportDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> ImportDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return ImportDeclSyntax(root: root, data: newData)
  }
  public var importTok: TokenSyntax {
    let child = data.cachedChild(at: Cursor.importTok)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `importTok` replaced.
  /// - param newChild: The new `importTok` to replace the node's
  ///                   current `importTok`, if present.
  public func withImportTok(
    _ newChild: TokenSyntax?) -> ImportDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.importKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.importTok)
    return ImportDeclSyntax(root: root, data: newData)
  }
  public var importKind: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.importKind)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `importKind` replaced.
  /// - param newChild: The new `importKind` to replace the node's
  ///                   current `importKind`, if present.
  public func withImportKind(
    _ newChild: TokenSyntax?) -> ImportDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.typealiasKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.importKind)
    return ImportDeclSyntax(root: root, data: newData)
  }
  public var path: AccessPathSyntax {
    let child = data.cachedChild(at: Cursor.path)
    return makeSyntax(root: _root, data: child!) as! AccessPathSyntax
  }

  /// Adds the provided `AccessPathComponent` to the node's `path`
  /// collection.
  /// - param element: The new `AccessPathComponent` to add to the node's
  ///                  `path` collection.
  /// - returns: A copy of the receiver with the provided `AccessPathComponent`
  ///            appended to its `path` collection.
  public func addAccessPathComponent(_ element: AccessPathComponentSyntax) -> ImportDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.path] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.accessPath,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.path)
    return ImportDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `path` replaced.
  /// - param newChild: The new `path` to replace the node's
  ///                   current `path`, if present.
  public func withPath(
    _ newChild: AccessPathSyntax?) -> ImportDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.accessPath)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.path)
    return ImportDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `ImportDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: ImportDeclSyntax, rhs: ImportDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AccessorParameterSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case name
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AccessorParameterSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> AccessorParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return AccessorParameterSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> AccessorParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return AccessorParameterSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> AccessorParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return AccessorParameterSyntax(root: root, data: newData)
  }

  /// Determines if two `AccessorParameterSyntax` nodes are equal to each other.
  public static func ==(lhs: AccessorParameterSyntax, rhs: AccessorParameterSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AccessorDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifier
    case accessorKind
    case parameter
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AccessorDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> AccessorDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return AccessorDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> AccessorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return AccessorDeclSyntax(root: root, data: newData)
  }
  public var modifier: DeclModifierSyntax? {
    let child = data.cachedChild(at: Cursor.modifier)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? DeclModifierSyntax
  }

  /// Returns a copy of the receiver with its `modifier` replaced.
  /// - param newChild: The new `modifier` to replace the node's
  ///                   current `modifier`, if present.
  public func withModifier(
    _ newChild: DeclModifierSyntax?) -> AccessorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.declModifier)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifier)
    return AccessorDeclSyntax(root: root, data: newData)
  }
  public var accessorKind: TokenSyntax {
    let child = data.cachedChild(at: Cursor.accessorKind)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `accessorKind` replaced.
  /// - param newChild: The new `accessorKind` to replace the node's
  ///                   current `accessorKind`, if present.
  public func withAccessorKind(
    _ newChild: TokenSyntax?) -> AccessorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.accessorKind)
    return AccessorDeclSyntax(root: root, data: newData)
  }
  public var parameter: AccessorParameterSyntax? {
    let child = data.cachedChild(at: Cursor.parameter)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AccessorParameterSyntax
  }

  /// Returns a copy of the receiver with its `parameter` replaced.
  /// - param newChild: The new `parameter` to replace the node's
  ///                   current `parameter`, if present.
  public func withParameter(
    _ newChild: AccessorParameterSyntax?) -> AccessorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.accessorParameter)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.parameter)
    return AccessorDeclSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax? {
    let child = data.cachedChild(at: Cursor.body)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> AccessorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return AccessorDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `AccessorDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: AccessorDeclSyntax, rhs: AccessorDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AccessorBlockSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftBrace
    case accessorListOrStmtList
    case rightBrace
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AccessorBlockSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBrace` replaced.
  /// - param newChild: The new `leftBrace` to replace the node's
  ///                   current `leftBrace`, if present.
  public func withLeftBrace(
    _ newChild: TokenSyntax?) -> AccessorBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBrace)
    return AccessorBlockSyntax(root: root, data: newData)
  }
  public var accessorListOrStmtList: Syntax {
    let child = data.cachedChild(at: Cursor.accessorListOrStmtList)
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `accessorListOrStmtList` replaced.
  /// - param newChild: The new `accessorListOrStmtList` to replace the node's
  ///                   current `accessorListOrStmtList`, if present.
  public func withAccessorListOrStmtList(
    _ newChild: Syntax?) -> AccessorBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.accessorListOrStmtList)
    return AccessorBlockSyntax(root: root, data: newData)
  }
  public var rightBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBrace` replaced.
  /// - param newChild: The new `rightBrace` to replace the node's
  ///                   current `rightBrace`, if present.
  public func withRightBrace(
    _ newChild: TokenSyntax?) -> AccessorBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBrace)
    return AccessorBlockSyntax(root: root, data: newData)
  }

  /// Determines if two `AccessorBlockSyntax` nodes are equal to each other.
  public static func ==(lhs: AccessorBlockSyntax, rhs: AccessorBlockSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PatternBindingSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case pattern
    case typeAnnotation
    case initializer
    case accessor
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PatternBindingSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> PatternBindingSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return PatternBindingSyntax(root: root, data: newData)
  }
  public var typeAnnotation: TypeAnnotationSyntax? {
    let child = data.cachedChild(at: Cursor.typeAnnotation)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeAnnotationSyntax
  }

  /// Returns a copy of the receiver with its `typeAnnotation` replaced.
  /// - param newChild: The new `typeAnnotation` to replace the node's
  ///                   current `typeAnnotation`, if present.
  public func withTypeAnnotation(
    _ newChild: TypeAnnotationSyntax?) -> PatternBindingSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeAnnotation)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeAnnotation)
    return PatternBindingSyntax(root: root, data: newData)
  }
  public var initializer: InitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.initializer)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `initializer` replaced.
  /// - param newChild: The new `initializer` to replace the node's
  ///                   current `initializer`, if present.
  public func withInitializer(
    _ newChild: InitializerClauseSyntax?) -> PatternBindingSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initializer)
    return PatternBindingSyntax(root: root, data: newData)
  }
  public var accessor: AccessorBlockSyntax? {
    let child = data.cachedChild(at: Cursor.accessor)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AccessorBlockSyntax
  }

  /// Returns a copy of the receiver with its `accessor` replaced.
  /// - param newChild: The new `accessor` to replace the node's
  ///                   current `accessor`, if present.
  public func withAccessor(
    _ newChild: AccessorBlockSyntax?) -> PatternBindingSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.accessorBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.accessor)
    return PatternBindingSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> PatternBindingSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return PatternBindingSyntax(root: root, data: newData)
  }

  /// Determines if two `PatternBindingSyntax` nodes are equal to each other.
  public static func ==(lhs: PatternBindingSyntax, rhs: PatternBindingSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct VariableDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case letOrVarKeyword
    case bindings
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `VariableDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> VariableDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return VariableDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> VariableDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return VariableDeclSyntax(root: root, data: newData)
  }
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> VariableDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return VariableDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> VariableDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return VariableDeclSyntax(root: root, data: newData)
  }
  public var letOrVarKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.letOrVarKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `letOrVarKeyword` replaced.
  /// - param newChild: The new `letOrVarKeyword` to replace the node's
  ///                   current `letOrVarKeyword`, if present.
  public func withLetOrVarKeyword(
    _ newChild: TokenSyntax?) -> VariableDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.letKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.letOrVarKeyword)
    return VariableDeclSyntax(root: root, data: newData)
  }
  public var bindings: PatternBindingListSyntax {
    let child = data.cachedChild(at: Cursor.bindings)
    return makeSyntax(root: _root, data: child!) as! PatternBindingListSyntax
  }

  /// Adds the provided `PatternBinding` to the node's `bindings`
  /// collection.
  /// - param element: The new `PatternBinding` to add to the node's
  ///                  `bindings` collection.
  /// - returns: A copy of the receiver with the provided `PatternBinding`
  ///            appended to its `bindings` collection.
  public func addPatternBinding(_ element: PatternBindingSyntax) -> VariableDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.bindings] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.patternBindingList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.bindings)
    return VariableDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `bindings` replaced.
  /// - param newChild: The new `bindings` to replace the node's
  ///                   current `bindings`, if present.
  public func withBindings(
    _ newChild: PatternBindingListSyntax?) -> VariableDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.patternBindingList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.bindings)
    return VariableDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `VariableDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: VariableDeclSyntax, rhs: VariableDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// An element of an enum case, containing the name of the case and,          optionally, either associated values or an assignment to a raw value.
/// 
public struct EnumCaseElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case identifier
    case associatedValue
    case rawValue
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `EnumCaseElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// The name of this case.
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> EnumCaseElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return EnumCaseElementSyntax(root: root, data: newData)
  }
  /// The set of associated values of the case.
  public var associatedValue: ParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.associatedValue)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `associatedValue` replaced.
  /// - param newChild: The new `associatedValue` to replace the node's
  ///                   current `associatedValue`, if present.
  public func withAssociatedValue(
    _ newChild: ParameterClauseSyntax?) -> EnumCaseElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.parameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.associatedValue)
    return EnumCaseElementSyntax(root: root, data: newData)
  }
  /// 
  /// The raw value of this enum element, if present.
  /// 
  public var rawValue: InitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.rawValue)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `rawValue` replaced.
  /// - param newChild: The new `rawValue` to replace the node's
  ///                   current `rawValue`, if present.
  public func withRawValue(
    _ newChild: InitializerClauseSyntax?) -> EnumCaseElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rawValue)
    return EnumCaseElementSyntax(root: root, data: newData)
  }
  /// 
  /// The trailing comma of this element, if the case has                    multiple elements.
  /// 
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> EnumCaseElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return EnumCaseElementSyntax(root: root, data: newData)
  }

  /// Determines if two `EnumCaseElementSyntax` nodes are equal to each other.
  public static func ==(lhs: EnumCaseElementSyntax, rhs: EnumCaseElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// A `case` declaration of a Swift `enum`. It can have 1 or more          `EnumCaseElement`s inside, each declaring a different case of the
/// enum.
/// 
public struct EnumCaseDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case caseKeyword
    case elements
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `EnumCaseDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// 
  /// The attributes applied to the case declaration.
  /// 
  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> EnumCaseDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> EnumCaseDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The declaration modifiers applied to the case declaration.
  /// 
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> EnumCaseDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> EnumCaseDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }
  /// The `case` keyword for this case.
  public var caseKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.caseKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `caseKeyword` replaced.
  /// - param newChild: The new `caseKeyword` to replace the node's
  ///                   current `caseKeyword`, if present.
  public func withCaseKeyword(
    _ newChild: TokenSyntax?) -> EnumCaseDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.caseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.caseKeyword)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }
  /// The elements this case declares.
  public var elements: EnumCaseElementListSyntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) as! EnumCaseElementListSyntax
  }

  /// Adds the provided `EnumCaseElement` to the node's `elements`
  /// collection.
  /// - param element: The new `EnumCaseElement` to add to the node's
  ///                  `elements` collection.
  /// - returns: A copy of the receiver with the provided `EnumCaseElement`
  ///            appended to its `elements` collection.
  public func addEnumCaseElement(_ element: EnumCaseElementSyntax) -> EnumCaseDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.enumCaseElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elements)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: EnumCaseElementListSyntax?) -> EnumCaseDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.enumCaseElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return EnumCaseDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `EnumCaseDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: EnumCaseDeclSyntax, rhs: EnumCaseDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// A Swift `enum` declaration.
public struct EnumDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case enumKeyword
    case identifier
    case genericParameters
    case inheritanceClause
    case genericWhereClause
    case members
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `EnumDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// 
  /// The attributes applied to the enum declaration.
  /// 
  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> EnumDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return EnumDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The declaration modifiers applied to the enum declaration.
  /// 
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> EnumDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return EnumDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The `enum` keyword for this declaration.
  /// 
  public var enumKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.enumKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `enumKeyword` replaced.
  /// - param newChild: The new `enumKeyword` to replace the node's
  ///                   current `enumKeyword`, if present.
  public func withEnumKeyword(
    _ newChild: TokenSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.enumKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.enumKeyword)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The name of this enum.
  /// 
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The generic parameters, if any, for this enum.
  /// 
  public var genericParameters: GenericParameterClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericParameters)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericParameterClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericParameters` replaced.
  /// - param newChild: The new `genericParameters` to replace the node's
  ///                   current `genericParameters`, if present.
  public func withGenericParameters(
    _ newChild: GenericParameterClauseSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameters)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The inheritance clause describing conformances or raw                    values for this enum.
  /// 
  public var inheritanceClause: TypeInheritanceClauseSyntax? {
    let child = data.cachedChild(at: Cursor.inheritanceClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeInheritanceClauseSyntax
  }

  /// Returns a copy of the receiver with its `inheritanceClause` replaced.
  /// - param newChild: The new `inheritanceClause` to replace the node's
  ///                   current `inheritanceClause`, if present.
  public func withInheritanceClause(
    _ newChild: TypeInheritanceClauseSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeInheritanceClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritanceClause)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The `where` clause that applies to the generic parameters of                    this enum.
  /// 
  public var genericWhereClause: GenericWhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericWhereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericWhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericWhereClause` replaced.
  /// - param newChild: The new `genericWhereClause` to replace the node's
  ///                   current `genericWhereClause`, if present.
  public func withGenericWhereClause(
    _ newChild: GenericWhereClauseSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericWhereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericWhereClause)
    return EnumDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The cases and other members of this enum.
  /// 
  public var members: MemberDeclBlockSyntax {
    let child = data.cachedChild(at: Cursor.members)
    return makeSyntax(root: _root, data: child!) as! MemberDeclBlockSyntax
  }

  /// Returns a copy of the receiver with its `members` replaced.
  /// - param newChild: The new `members` to replace the node's
  ///                   current `members`, if present.
  public func withMembers(
    _ newChild: MemberDeclBlockSyntax?) -> EnumDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.memberDeclBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.members)
    return EnumDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `EnumDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: EnumDeclSyntax, rhs: EnumDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// A Swift `operator` declaration.
public struct OperatorDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case operatorKeyword
    case identifier
    case infixOperatorGroup
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `OperatorDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// 
  /// The attributes applied to the 'operator' declaration.
  /// 
  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> OperatorDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return OperatorDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> OperatorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return OperatorDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The declaration modifiers applied to the 'operator'
  /// declaration.
  /// 
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> OperatorDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return OperatorDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> OperatorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return OperatorDeclSyntax(root: root, data: newData)
  }
  public var operatorKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.operatorKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `operatorKeyword` replaced.
  /// - param newChild: The new `operatorKeyword` to replace the node's
  ///                   current `operatorKeyword`, if present.
  public func withOperatorKeyword(
    _ newChild: TokenSyntax?) -> OperatorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.operatorKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.operatorKeyword)
    return OperatorDeclSyntax(root: root, data: newData)
  }
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> OperatorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unspacedBinaryOperator(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return OperatorDeclSyntax(root: root, data: newData)
  }
  /// 
  /// Optionally specifiy a precedence group
  /// 
  public var infixOperatorGroup: InfixOperatorGroupSyntax? {
    let child = data.cachedChild(at: Cursor.infixOperatorGroup)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? InfixOperatorGroupSyntax
  }

  /// Returns a copy of the receiver with its `infixOperatorGroup` replaced.
  /// - param newChild: The new `infixOperatorGroup` to replace the node's
  ///                   current `infixOperatorGroup`, if present.
  public func withInfixOperatorGroup(
    _ newChild: InfixOperatorGroupSyntax?) -> OperatorDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.infixOperatorGroup)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.infixOperatorGroup)
    return OperatorDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `OperatorDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: OperatorDeclSyntax, rhs: OperatorDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// A clause to specify precedence group in infix operator declaration.
/// 
public struct InfixOperatorGroupSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case colon
    case precedenceGroupName
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `InfixOperatorGroupSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> InfixOperatorGroupSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return InfixOperatorGroupSyntax(root: root, data: newData)
  }
  /// 
  /// The name of the precedence group for the operator
  /// 
  public var precedenceGroupName: TokenSyntax {
    let child = data.cachedChild(at: Cursor.precedenceGroupName)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `precedenceGroupName` replaced.
  /// - param newChild: The new `precedenceGroupName` to replace the node's
  ///                   current `precedenceGroupName`, if present.
  public func withPrecedenceGroupName(
    _ newChild: TokenSyntax?) -> InfixOperatorGroupSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.precedenceGroupName)
    return InfixOperatorGroupSyntax(root: root, data: newData)
  }

  /// Determines if two `InfixOperatorGroupSyntax` nodes are equal to each other.
  public static func ==(lhs: InfixOperatorGroupSyntax, rhs: InfixOperatorGroupSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// A Swift `precedencegroup` declaration.
public struct PrecedenceGroupDeclSyntax: DeclSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case modifiers
    case precedencegroupKeyword
    case identifier
    case leftBrace
    case groupAttributes
    case rightBrace
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PrecedenceGroupDeclSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// 
  /// The attributes applied to the 'precedencegroup' declaration.
  /// 
  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> PrecedenceGroupDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The declaration modifiers applied to the 'precedencegroup'
  /// declaration.
  /// 
  public var modifiers: ModifierListSyntax? {
    let child = data.cachedChild(at: Cursor.modifiers)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ModifierListSyntax
  }

  /// Adds the provided `Modifier` to the node's `modifiers`
  /// collection.
  /// - param element: The new `Modifier` to add to the node's
  ///                  `modifiers` collection.
  /// - returns: A copy of the receiver with the provided `Modifier`
  ///            appended to its `modifiers` collection.
  public func addModifier(_ element: DeclModifierSyntax) -> PrecedenceGroupDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.modifiers] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.modifierList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.modifiers)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `modifiers` replaced.
  /// - param newChild: The new `modifiers` to replace the node's
  ///                   current `modifiers`, if present.
  public func withModifiers(
    _ newChild: ModifierListSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.modifierList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.modifiers)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }
  public var precedencegroupKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.precedencegroupKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `precedencegroupKeyword` replaced.
  /// - param newChild: The new `precedencegroupKeyword` to replace the node's
  ///                   current `precedencegroupKeyword`, if present.
  public func withPrecedencegroupKeyword(
    _ newChild: TokenSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.precedencegroupKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.precedencegroupKeyword)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The name of this precedence group.
  /// 
  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }
  public var leftBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBrace` replaced.
  /// - param newChild: The new `leftBrace` to replace the node's
  ///                   current `leftBrace`, if present.
  public func withLeftBrace(
    _ newChild: TokenSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBrace)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }
  /// 
  /// The characteristics of this precedence group.
  /// 
  public var groupAttributes: PrecedenceGroupAttributeListSyntax {
    let child = data.cachedChild(at: Cursor.groupAttributes)
    return makeSyntax(root: _root, data: child!) as! PrecedenceGroupAttributeListSyntax
  }

  /// Adds the provided `Syntax` to the node's `groupAttributes`
  /// collection.
  /// - param element: The new `Syntax` to add to the node's
  ///                  `groupAttributes` collection.
  /// - returns: A copy of the receiver with the provided `Syntax`
  ///            appended to its `groupAttributes` collection.
  public func addSyntax(_ element: Syntax) -> PrecedenceGroupDeclSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.groupAttributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.precedenceGroupAttributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.groupAttributes)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `groupAttributes` replaced.
  /// - param newChild: The new `groupAttributes` to replace the node's
  ///                   current `groupAttributes`, if present.
  public func withGroupAttributes(
    _ newChild: PrecedenceGroupAttributeListSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.precedenceGroupAttributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.groupAttributes)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }
  public var rightBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBrace` replaced.
  /// - param newChild: The new `rightBrace` to replace the node's
  ///                   current `rightBrace`, if present.
  public func withRightBrace(
    _ newChild: TokenSyntax?) -> PrecedenceGroupDeclSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBrace)
    return PrecedenceGroupDeclSyntax(root: root, data: newData)
  }

  /// Determines if two `PrecedenceGroupDeclSyntax` nodes are equal to each other.
  public static func ==(lhs: PrecedenceGroupDeclSyntax, rhs: PrecedenceGroupDeclSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// Specify the new precedence group's relation to existing precedence
/// groups.
/// 
public struct PrecedenceGroupRelationSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case higherThanOrLowerThan
    case colon
    case otherNames
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PrecedenceGroupRelationSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  /// 
  /// The relation to specified other precedence groups.
  /// 
  public var higherThanOrLowerThan: TokenSyntax {
    let child = data.cachedChild(at: Cursor.higherThanOrLowerThan)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `higherThanOrLowerThan` replaced.
  /// - param newChild: The new `higherThanOrLowerThan` to replace the node's
  ///                   current `higherThanOrLowerThan`, if present.
  public func withHigherThanOrLowerThan(
    _ newChild: TokenSyntax?) -> PrecedenceGroupRelationSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.higherThanOrLowerThan)
    return PrecedenceGroupRelationSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> PrecedenceGroupRelationSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return PrecedenceGroupRelationSyntax(root: root, data: newData)
  }
  /// 
  /// The name of other precedence group to which this precedence
  /// group relates.
  /// 
  public var otherNames: PrecedenceGroupNameListSyntax {
    let child = data.cachedChild(at: Cursor.otherNames)
    return makeSyntax(root: _root, data: child!) as! PrecedenceGroupNameListSyntax
  }

  /// Adds the provided `PrecedenceGroupNameElement` to the node's `otherNames`
  /// collection.
  /// - param element: The new `PrecedenceGroupNameElement` to add to the node's
  ///                  `otherNames` collection.
  /// - returns: A copy of the receiver with the provided `PrecedenceGroupNameElement`
  ///            appended to its `otherNames` collection.
  public func addPrecedenceGroupNameElement(_ element: PrecedenceGroupNameElementSyntax) -> PrecedenceGroupRelationSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.otherNames] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.precedenceGroupNameList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.otherNames)
    return PrecedenceGroupRelationSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `otherNames` replaced.
  /// - param newChild: The new `otherNames` to replace the node's
  ///                   current `otherNames`, if present.
  public func withOtherNames(
    _ newChild: PrecedenceGroupNameListSyntax?) -> PrecedenceGroupRelationSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.precedenceGroupNameList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.otherNames)
    return PrecedenceGroupRelationSyntax(root: root, data: newData)
  }

  /// Determines if two `PrecedenceGroupRelationSyntax` nodes are equal to each other.
  public static func ==(lhs: PrecedenceGroupRelationSyntax, rhs: PrecedenceGroupRelationSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct PrecedenceGroupNameElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PrecedenceGroupNameElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> PrecedenceGroupNameElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return PrecedenceGroupNameElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> PrecedenceGroupNameElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return PrecedenceGroupNameElementSyntax(root: root, data: newData)
  }

  /// Determines if two `PrecedenceGroupNameElementSyntax` nodes are equal to each other.
  public static func ==(lhs: PrecedenceGroupNameElementSyntax, rhs: PrecedenceGroupNameElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// Specifies the precedence of an operator when used in an operation
/// that includes optional chaining.
/// 
public struct PrecedenceGroupAssignmentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case assignmentKeyword
    case colon
    case flag
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PrecedenceGroupAssignmentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var assignmentKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.assignmentKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `assignmentKeyword` replaced.
  /// - param newChild: The new `assignmentKeyword` to replace the node's
  ///                   current `assignmentKeyword`, if present.
  public func withAssignmentKeyword(
    _ newChild: TokenSyntax?) -> PrecedenceGroupAssignmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.assignmentKeyword)
    return PrecedenceGroupAssignmentSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> PrecedenceGroupAssignmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return PrecedenceGroupAssignmentSyntax(root: root, data: newData)
  }
  /// 
  /// When true, an operator in the corresponding precedence group
  /// uses the same grouping rules during optional chaining as the
  /// assignment operators from the standard library. Otherwise,
  /// operators in the precedence group follows the same optional
  /// chaining rules as operators that don't perform assignment.
  /// 
  public var flag: TokenSyntax {
    let child = data.cachedChild(at: Cursor.flag)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `flag` replaced.
  /// - param newChild: The new `flag` to replace the node's
  ///                   current `flag`, if present.
  public func withFlag(
    _ newChild: TokenSyntax?) -> PrecedenceGroupAssignmentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.trueKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.flag)
    return PrecedenceGroupAssignmentSyntax(root: root, data: newData)
  }

  /// Determines if two `PrecedenceGroupAssignmentSyntax` nodes are equal to each other.
  public static func ==(lhs: PrecedenceGroupAssignmentSyntax, rhs: PrecedenceGroupAssignmentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


/// 
/// Specifies how a sequence of operators with the same precedence level
/// are grouped together in the absence of grouping parentheses.
/// 
public struct PrecedenceGroupAssociativitySyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case associativityKeyword
    case colon
    case value
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `PrecedenceGroupAssociativitySyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var associativityKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.associativityKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `associativityKeyword` replaced.
  /// - param newChild: The new `associativityKeyword` to replace the node's
  ///                   current `associativityKeyword`, if present.
  public func withAssociativityKeyword(
    _ newChild: TokenSyntax?) -> PrecedenceGroupAssociativitySyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.associativityKeyword)
    return PrecedenceGroupAssociativitySyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> PrecedenceGroupAssociativitySyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return PrecedenceGroupAssociativitySyntax(root: root, data: newData)
  }
  /// 
  /// Operators that are `left`-associative group left-to-right.
  /// Operators that are `right`-associative group right-to-left.
  /// Operators that are specified with an associativity of `none`
  /// don't associate at all
  /// 
  public var value: TokenSyntax {
    let child = data.cachedChild(at: Cursor.value)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `value` replaced.
  /// - param newChild: The new `value` to replace the node's
  ///                   current `value`, if present.
  public func withValue(
    _ newChild: TokenSyntax?) -> PrecedenceGroupAssociativitySyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.value)
    return PrecedenceGroupAssociativitySyntax(root: root, data: newData)
  }

  /// Determines if two `PrecedenceGroupAssociativitySyntax` nodes are equal to each other.
  public static func ==(lhs: PrecedenceGroupAssociativitySyntax, rhs: PrecedenceGroupAssociativitySyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AttributeSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case atSignToken
    case attributeName
    case balancedTokens
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AttributeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var atSignToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.atSignToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `atSignToken` replaced.
  /// - param newChild: The new `atSignToken` to replace the node's
  ///                   current `atSignToken`, if present.
  public func withAtSignToken(
    _ newChild: TokenSyntax?) -> AttributeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.atSign)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.atSignToken)
    return AttributeSyntax(root: root, data: newData)
  }
  public var attributeName: TokenSyntax {
    let child = data.cachedChild(at: Cursor.attributeName)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `attributeName` replaced.
  /// - param newChild: The new `attributeName` to replace the node's
  ///                   current `attributeName`, if present.
  public func withAttributeName(
    _ newChild: TokenSyntax?) -> AttributeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributeName)
    return AttributeSyntax(root: root, data: newData)
  }
  public var balancedTokens: TokenListSyntax {
    let child = data.cachedChild(at: Cursor.balancedTokens)
    return makeSyntax(root: _root, data: child!) as! TokenListSyntax
  }

  /// Adds the provided `Token` to the node's `balancedTokens`
  /// collection.
  /// - param element: The new `Token` to add to the node's
  ///                  `balancedTokens` collection.
  /// - returns: A copy of the receiver with the provided `Token`
  ///            appended to its `balancedTokens` collection.
  public func addToken(_ element: TokenSyntax) -> AttributeSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.balancedTokens] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tokenList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.balancedTokens)
    return AttributeSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `balancedTokens` replaced.
  /// - param newChild: The new `balancedTokens` to replace the node's
  ///                   current `balancedTokens`, if present.
  public func withBalancedTokens(
    _ newChild: TokenListSyntax?) -> AttributeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.balancedTokens)
    return AttributeSyntax(root: root, data: newData)
  }

  /// Determines if two `AttributeSyntax` nodes are equal to each other.
  public static func ==(lhs: AttributeSyntax, rhs: AttributeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ContinueStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case continueKeyword
    case label
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ContinueStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var continueKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.continueKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `continueKeyword` replaced.
  /// - param newChild: The new `continueKeyword` to replace the node's
  ///                   current `continueKeyword`, if present.
  public func withContinueKeyword(
    _ newChild: TokenSyntax?) -> ContinueStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.continueKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.continueKeyword)
    return ContinueStmtSyntax(root: root, data: newData)
  }
  public var label: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.label)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `label` replaced.
  /// - param newChild: The new `label` to replace the node's
  ///                   current `label`, if present.
  public func withLabel(
    _ newChild: TokenSyntax?) -> ContinueStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.label)
    return ContinueStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `ContinueStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: ContinueStmtSyntax, rhs: ContinueStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct WhileStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case whileKeyword
    case conditions
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `WhileStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> WhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return WhileStmtSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> WhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return WhileStmtSyntax(root: root, data: newData)
  }
  public var whileKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.whileKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `whileKeyword` replaced.
  /// - param newChild: The new `whileKeyword` to replace the node's
  ///                   current `whileKeyword`, if present.
  public func withWhileKeyword(
    _ newChild: TokenSyntax?) -> WhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.whileKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whileKeyword)
    return WhileStmtSyntax(root: root, data: newData)
  }
  public var conditions: ConditionElementListSyntax {
    let child = data.cachedChild(at: Cursor.conditions)
    return makeSyntax(root: _root, data: child!) as! ConditionElementListSyntax
  }

  /// Adds the provided `ConditionElement` to the node's `conditions`
  /// collection.
  /// - param element: The new `ConditionElement` to add to the node's
  ///                  `conditions` collection.
  /// - returns: A copy of the receiver with the provided `ConditionElement`
  ///            appended to its `conditions` collection.
  public func addConditionElement(_ element: ConditionElementSyntax) -> WhileStmtSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.conditions] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.conditionElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.conditions)
    return WhileStmtSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `conditions` replaced.
  /// - param newChild: The new `conditions` to replace the node's
  ///                   current `conditions`, if present.
  public func withConditions(
    _ newChild: ConditionElementListSyntax?) -> WhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.conditionElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.conditions)
    return WhileStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> WhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return WhileStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `WhileStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: WhileStmtSyntax, rhs: WhileStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DeferStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case deferKeyword
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DeferStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var deferKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.deferKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `deferKeyword` replaced.
  /// - param newChild: The new `deferKeyword` to replace the node's
  ///                   current `deferKeyword`, if present.
  public func withDeferKeyword(
    _ newChild: TokenSyntax?) -> DeferStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.deferKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.deferKeyword)
    return DeferStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> DeferStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return DeferStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `DeferStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: DeferStmtSyntax, rhs: DeferStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ExpressionStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ExpressionStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ExpressionStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ExpressionStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `ExpressionStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: ExpressionStmtSyntax, rhs: ExpressionStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct RepeatWhileStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case repeatKeyword
    case body
    case whileKeyword
    case condition
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `RepeatWhileStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> RepeatWhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return RepeatWhileStmtSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> RepeatWhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return RepeatWhileStmtSyntax(root: root, data: newData)
  }
  public var repeatKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.repeatKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `repeatKeyword` replaced.
  /// - param newChild: The new `repeatKeyword` to replace the node's
  ///                   current `repeatKeyword`, if present.
  public func withRepeatKeyword(
    _ newChild: TokenSyntax?) -> RepeatWhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.repeatKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.repeatKeyword)
    return RepeatWhileStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> RepeatWhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return RepeatWhileStmtSyntax(root: root, data: newData)
  }
  public var whileKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.whileKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `whileKeyword` replaced.
  /// - param newChild: The new `whileKeyword` to replace the node's
  ///                   current `whileKeyword`, if present.
  public func withWhileKeyword(
    _ newChild: TokenSyntax?) -> RepeatWhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.whileKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whileKeyword)
    return RepeatWhileStmtSyntax(root: root, data: newData)
  }
  public var condition: ExprSyntax {
    let child = data.cachedChild(at: Cursor.condition)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `condition` replaced.
  /// - param newChild: The new `condition` to replace the node's
  ///                   current `condition`, if present.
  public func withCondition(
    _ newChild: ExprSyntax?) -> RepeatWhileStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.condition)
    return RepeatWhileStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `RepeatWhileStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: RepeatWhileStmtSyntax, rhs: RepeatWhileStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct GuardStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case guardKeyword
    case conditions
    case elseKeyword
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `GuardStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var guardKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.guardKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `guardKeyword` replaced.
  /// - param newChild: The new `guardKeyword` to replace the node's
  ///                   current `guardKeyword`, if present.
  public func withGuardKeyword(
    _ newChild: TokenSyntax?) -> GuardStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.guardKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.guardKeyword)
    return GuardStmtSyntax(root: root, data: newData)
  }
  public var conditions: ConditionElementListSyntax {
    let child = data.cachedChild(at: Cursor.conditions)
    return makeSyntax(root: _root, data: child!) as! ConditionElementListSyntax
  }

  /// Adds the provided `ConditionElement` to the node's `conditions`
  /// collection.
  /// - param element: The new `ConditionElement` to add to the node's
  ///                  `conditions` collection.
  /// - returns: A copy of the receiver with the provided `ConditionElement`
  ///            appended to its `conditions` collection.
  public func addConditionElement(_ element: ConditionElementSyntax) -> GuardStmtSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.conditions] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.conditionElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.conditions)
    return GuardStmtSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `conditions` replaced.
  /// - param newChild: The new `conditions` to replace the node's
  ///                   current `conditions`, if present.
  public func withConditions(
    _ newChild: ConditionElementListSyntax?) -> GuardStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.conditionElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.conditions)
    return GuardStmtSyntax(root: root, data: newData)
  }
  public var elseKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.elseKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `elseKeyword` replaced.
  /// - param newChild: The new `elseKeyword` to replace the node's
  ///                   current `elseKeyword`, if present.
  public func withElseKeyword(
    _ newChild: TokenSyntax?) -> GuardStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.elseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elseKeyword)
    return GuardStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> GuardStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return GuardStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `GuardStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: GuardStmtSyntax, rhs: GuardStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct WhereClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case whereKeyword
    case guardResult
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `WhereClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var whereKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.whereKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `whereKeyword` replaced.
  /// - param newChild: The new `whereKeyword` to replace the node's
  ///                   current `whereKeyword`, if present.
  public func withWhereKeyword(
    _ newChild: TokenSyntax?) -> WhereClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.whereKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whereKeyword)
    return WhereClauseSyntax(root: root, data: newData)
  }
  public var guardResult: ExprSyntax {
    let child = data.cachedChild(at: Cursor.guardResult)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `guardResult` replaced.
  /// - param newChild: The new `guardResult` to replace the node's
  ///                   current `guardResult`, if present.
  public func withGuardResult(
    _ newChild: ExprSyntax?) -> WhereClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.guardResult)
    return WhereClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `WhereClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: WhereClauseSyntax, rhs: WhereClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ForInStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case forKeyword
    case caseKeyword
    case pattern
    case typeAnnotation
    case inKeyword
    case sequenceExpr
    case whereClause
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ForInStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var forKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.forKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `forKeyword` replaced.
  /// - param newChild: The new `forKeyword` to replace the node's
  ///                   current `forKeyword`, if present.
  public func withForKeyword(
    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.forKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.forKeyword)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var caseKeyword: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.caseKeyword)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `caseKeyword` replaced.
  /// - param newChild: The new `caseKeyword` to replace the node's
  ///                   current `caseKeyword`, if present.
  public func withCaseKeyword(
    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.caseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.caseKeyword)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var typeAnnotation: TypeAnnotationSyntax? {
    let child = data.cachedChild(at: Cursor.typeAnnotation)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeAnnotationSyntax
  }

  /// Returns a copy of the receiver with its `typeAnnotation` replaced.
  /// - param newChild: The new `typeAnnotation` to replace the node's
  ///                   current `typeAnnotation`, if present.
  public func withTypeAnnotation(
    _ newChild: TypeAnnotationSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeAnnotation)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeAnnotation)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var inKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.inKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `inKeyword` replaced.
  /// - param newChild: The new `inKeyword` to replace the node's
  ///                   current `inKeyword`, if present.
  public func withInKeyword(
    _ newChild: TokenSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.inKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inKeyword)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var sequenceExpr: ExprSyntax {
    let child = data.cachedChild(at: Cursor.sequenceExpr)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `sequenceExpr` replaced.
  /// - param newChild: The new `sequenceExpr` to replace the node's
  ///                   current `sequenceExpr`, if present.
  public func withSequenceExpr(
    _ newChild: ExprSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.sequenceExpr)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var whereClause: WhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.whereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? WhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `whereClause` replaced.
  /// - param newChild: The new `whereClause` to replace the node's
  ///                   current `whereClause`, if present.
  public func withWhereClause(
    _ newChild: WhereClauseSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.whereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whereClause)
    return ForInStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> ForInStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return ForInStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `ForInStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: ForInStmtSyntax, rhs: ForInStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SwitchStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case switchKeyword
    case expression
    case leftBrace
    case cases
    case rightBrace
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SwitchStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return SwitchStmtSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return SwitchStmtSyntax(root: root, data: newData)
  }
  public var switchKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.switchKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `switchKeyword` replaced.
  /// - param newChild: The new `switchKeyword` to replace the node's
  ///                   current `switchKeyword`, if present.
  public func withSwitchKeyword(
    _ newChild: TokenSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.switchKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.switchKeyword)
    return SwitchStmtSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return SwitchStmtSyntax(root: root, data: newData)
  }
  public var leftBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftBrace` replaced.
  /// - param newChild: The new `leftBrace` to replace the node's
  ///                   current `leftBrace`, if present.
  public func withLeftBrace(
    _ newChild: TokenSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftBrace)
    return SwitchStmtSyntax(root: root, data: newData)
  }
  public var cases: SwitchCaseListSyntax {
    let child = data.cachedChild(at: Cursor.cases)
    return makeSyntax(root: _root, data: child!) as! SwitchCaseListSyntax
  }

  /// Adds the provided `Syntax` to the node's `cases`
  /// collection.
  /// - param element: The new `Syntax` to add to the node's
  ///                  `cases` collection.
  /// - returns: A copy of the receiver with the provided `Syntax`
  ///            appended to its `cases` collection.
  public func addSyntax(_ element: Syntax) -> SwitchStmtSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.cases] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.switchCaseList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.cases)
    return SwitchStmtSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `cases` replaced.
  /// - param newChild: The new `cases` to replace the node's
  ///                   current `cases`, if present.
  public func withCases(
    _ newChild: SwitchCaseListSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.switchCaseList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.cases)
    return SwitchStmtSyntax(root: root, data: newData)
  }
  public var rightBrace: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightBrace)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightBrace` replaced.
  /// - param newChild: The new `rightBrace` to replace the node's
  ///                   current `rightBrace`, if present.
  public func withRightBrace(
    _ newChild: TokenSyntax?) -> SwitchStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightBrace)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightBrace)
    return SwitchStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `SwitchStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: SwitchStmtSyntax, rhs: SwitchStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DoStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case doKeyword
    case body
    case catchClauses
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DoStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> DoStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return DoStmtSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> DoStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return DoStmtSyntax(root: root, data: newData)
  }
  public var doKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.doKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `doKeyword` replaced.
  /// - param newChild: The new `doKeyword` to replace the node's
  ///                   current `doKeyword`, if present.
  public func withDoKeyword(
    _ newChild: TokenSyntax?) -> DoStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.doKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.doKeyword)
    return DoStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> DoStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return DoStmtSyntax(root: root, data: newData)
  }
  public var catchClauses: CatchClauseListSyntax? {
    let child = data.cachedChild(at: Cursor.catchClauses)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? CatchClauseListSyntax
  }

  /// Adds the provided `CatchClause` to the node's `catchClauses`
  /// collection.
  /// - param element: The new `CatchClause` to add to the node's
  ///                  `catchClauses` collection.
  /// - returns: A copy of the receiver with the provided `CatchClause`
  ///            appended to its `catchClauses` collection.
  public func addCatchClause(_ element: CatchClauseSyntax) -> DoStmtSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.catchClauses] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.catchClauseList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.catchClauses)
    return DoStmtSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `catchClauses` replaced.
  /// - param newChild: The new `catchClauses` to replace the node's
  ///                   current `catchClauses`, if present.
  public func withCatchClauses(
    _ newChild: CatchClauseListSyntax?) -> DoStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.catchClauseList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.catchClauses)
    return DoStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `DoStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: DoStmtSyntax, rhs: DoStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ReturnStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case returnKeyword
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ReturnStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var returnKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.returnKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `returnKeyword` replaced.
  /// - param newChild: The new `returnKeyword` to replace the node's
  ///                   current `returnKeyword`, if present.
  public func withReturnKeyword(
    _ newChild: TokenSyntax?) -> ReturnStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.returnKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.returnKeyword)
    return ReturnStmtSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax? {
    let child = data.cachedChild(at: Cursor.expression)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ReturnStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ReturnStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `ReturnStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: ReturnStmtSyntax, rhs: ReturnStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FallthroughStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case fallthroughKeyword
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FallthroughStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var fallthroughKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.fallthroughKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `fallthroughKeyword` replaced.
  /// - param newChild: The new `fallthroughKeyword` to replace the node's
  ///                   current `fallthroughKeyword`, if present.
  public func withFallthroughKeyword(
    _ newChild: TokenSyntax?) -> FallthroughStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.fallthroughKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.fallthroughKeyword)
    return FallthroughStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `FallthroughStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: FallthroughStmtSyntax, rhs: FallthroughStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct BreakStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case breakKeyword
    case label
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `BreakStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var breakKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.breakKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `breakKeyword` replaced.
  /// - param newChild: The new `breakKeyword` to replace the node's
  ///                   current `breakKeyword`, if present.
  public func withBreakKeyword(
    _ newChild: TokenSyntax?) -> BreakStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.breakKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.breakKeyword)
    return BreakStmtSyntax(root: root, data: newData)
  }
  public var label: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.label)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `label` replaced.
  /// - param newChild: The new `label` to replace the node's
  ///                   current `label`, if present.
  public func withLabel(
    _ newChild: TokenSyntax?) -> BreakStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.label)
    return BreakStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `BreakStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: BreakStmtSyntax, rhs: BreakStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ConditionElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case condition
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ConditionElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var condition: Syntax {
    let child = data.cachedChild(at: Cursor.condition)
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `condition` replaced.
  /// - param newChild: The new `condition` to replace the node's
  ///                   current `condition`, if present.
  public func withCondition(
    _ newChild: Syntax?) -> ConditionElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.condition)
    return ConditionElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> ConditionElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return ConditionElementSyntax(root: root, data: newData)
  }

  /// Determines if two `ConditionElementSyntax` nodes are equal to each other.
  public static func ==(lhs: ConditionElementSyntax, rhs: ConditionElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AvailabilityConditionSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case poundAvailableKeyword
    case arguments
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AvailabilityConditionSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var poundAvailableKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.poundAvailableKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `poundAvailableKeyword` replaced.
  /// - param newChild: The new `poundAvailableKeyword` to replace the node's
  ///                   current `poundAvailableKeyword`, if present.
  public func withPoundAvailableKeyword(
    _ newChild: TokenSyntax?) -> AvailabilityConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.poundAvailableKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.poundAvailableKeyword)
    return AvailabilityConditionSyntax(root: root, data: newData)
  }
  public var arguments: TokenListSyntax {
    let child = data.cachedChild(at: Cursor.arguments)
    return makeSyntax(root: _root, data: child!) as! TokenListSyntax
  }

  /// Adds the provided `Token` to the node's `arguments`
  /// collection.
  /// - param element: The new `Token` to add to the node's
  ///                  `arguments` collection.
  /// - returns: A copy of the receiver with the provided `Token`
  ///            appended to its `arguments` collection.
  public func addToken(_ element: TokenSyntax) -> AvailabilityConditionSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.arguments] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tokenList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.arguments)
    return AvailabilityConditionSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `arguments` replaced.
  /// - param newChild: The new `arguments` to replace the node's
  ///                   current `arguments`, if present.
  public func withArguments(
    _ newChild: TokenListSyntax?) -> AvailabilityConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arguments)
    return AvailabilityConditionSyntax(root: root, data: newData)
  }

  /// Determines if two `AvailabilityConditionSyntax` nodes are equal to each other.
  public static func ==(lhs: AvailabilityConditionSyntax, rhs: AvailabilityConditionSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct MatchingPatternConditionSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case caseKeyword
    case pattern
    case typeAnnotation
    case initializer
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `MatchingPatternConditionSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var caseKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.caseKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `caseKeyword` replaced.
  /// - param newChild: The new `caseKeyword` to replace the node's
  ///                   current `caseKeyword`, if present.
  public func withCaseKeyword(
    _ newChild: TokenSyntax?) -> MatchingPatternConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.caseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.caseKeyword)
    return MatchingPatternConditionSyntax(root: root, data: newData)
  }
  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> MatchingPatternConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return MatchingPatternConditionSyntax(root: root, data: newData)
  }
  public var typeAnnotation: TypeAnnotationSyntax? {
    let child = data.cachedChild(at: Cursor.typeAnnotation)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeAnnotationSyntax
  }

  /// Returns a copy of the receiver with its `typeAnnotation` replaced.
  /// - param newChild: The new `typeAnnotation` to replace the node's
  ///                   current `typeAnnotation`, if present.
  public func withTypeAnnotation(
    _ newChild: TypeAnnotationSyntax?) -> MatchingPatternConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeAnnotation)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeAnnotation)
    return MatchingPatternConditionSyntax(root: root, data: newData)
  }
  public var initializer: InitializerClauseSyntax {
    let child = data.cachedChild(at: Cursor.initializer)
    return makeSyntax(root: _root, data: child!) as! InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `initializer` replaced.
  /// - param newChild: The new `initializer` to replace the node's
  ///                   current `initializer`, if present.
  public func withInitializer(
    _ newChild: InitializerClauseSyntax?) -> MatchingPatternConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initializer)
    return MatchingPatternConditionSyntax(root: root, data: newData)
  }

  /// Determines if two `MatchingPatternConditionSyntax` nodes are equal to each other.
  public static func ==(lhs: MatchingPatternConditionSyntax, rhs: MatchingPatternConditionSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct OptionalBindingConditionSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case letOrVarKeyword
    case pattern
    case typeAnnotation
    case initializer
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `OptionalBindingConditionSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var letOrVarKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.letOrVarKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `letOrVarKeyword` replaced.
  /// - param newChild: The new `letOrVarKeyword` to replace the node's
  ///                   current `letOrVarKeyword`, if present.
  public func withLetOrVarKeyword(
    _ newChild: TokenSyntax?) -> OptionalBindingConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.letKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.letOrVarKeyword)
    return OptionalBindingConditionSyntax(root: root, data: newData)
  }
  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> OptionalBindingConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return OptionalBindingConditionSyntax(root: root, data: newData)
  }
  public var typeAnnotation: TypeAnnotationSyntax? {
    let child = data.cachedChild(at: Cursor.typeAnnotation)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeAnnotationSyntax
  }

  /// Returns a copy of the receiver with its `typeAnnotation` replaced.
  /// - param newChild: The new `typeAnnotation` to replace the node's
  ///                   current `typeAnnotation`, if present.
  public func withTypeAnnotation(
    _ newChild: TypeAnnotationSyntax?) -> OptionalBindingConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeAnnotation)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeAnnotation)
    return OptionalBindingConditionSyntax(root: root, data: newData)
  }
  public var initializer: InitializerClauseSyntax {
    let child = data.cachedChild(at: Cursor.initializer)
    return makeSyntax(root: _root, data: child!) as! InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `initializer` replaced.
  /// - param newChild: The new `initializer` to replace the node's
  ///                   current `initializer`, if present.
  public func withInitializer(
    _ newChild: InitializerClauseSyntax?) -> OptionalBindingConditionSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initializer)
    return OptionalBindingConditionSyntax(root: root, data: newData)
  }

  /// Determines if two `OptionalBindingConditionSyntax` nodes are equal to each other.
  public static func ==(lhs: OptionalBindingConditionSyntax, rhs: OptionalBindingConditionSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DeclarationStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case declaration
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DeclarationStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var declaration: DeclSyntax {
    let child = data.cachedChild(at: Cursor.declaration)
    return makeSyntax(root: _root, data: child!) as! DeclSyntax
  }

  /// Returns a copy of the receiver with its `declaration` replaced.
  /// - param newChild: The new `declaration` to replace the node's
  ///                   current `declaration`, if present.
  public func withDeclaration(
    _ newChild: DeclSyntax?) -> DeclarationStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.decl)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.declaration)
    return DeclarationStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `DeclarationStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: DeclarationStmtSyntax, rhs: DeclarationStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ThrowStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case throwKeyword
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ThrowStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var throwKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.throwKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `throwKeyword` replaced.
  /// - param newChild: The new `throwKeyword` to replace the node's
  ///                   current `throwKeyword`, if present.
  public func withThrowKeyword(
    _ newChild: TokenSyntax?) -> ThrowStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.throwKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.throwKeyword)
    return ThrowStmtSyntax(root: root, data: newData)
  }
  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ThrowStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ThrowStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `ThrowStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: ThrowStmtSyntax, rhs: ThrowStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IfStmtSyntax: StmtSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case ifKeyword
    case conditions
    case body
    case elseKeyword
    case elseBody
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IfStmtSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return IfStmtSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return IfStmtSyntax(root: root, data: newData)
  }
  public var ifKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.ifKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `ifKeyword` replaced.
  /// - param newChild: The new `ifKeyword` to replace the node's
  ///                   current `ifKeyword`, if present.
  public func withIfKeyword(
    _ newChild: TokenSyntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.ifKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ifKeyword)
    return IfStmtSyntax(root: root, data: newData)
  }
  public var conditions: ConditionElementListSyntax {
    let child = data.cachedChild(at: Cursor.conditions)
    return makeSyntax(root: _root, data: child!) as! ConditionElementListSyntax
  }

  /// Adds the provided `ConditionElement` to the node's `conditions`
  /// collection.
  /// - param element: The new `ConditionElement` to add to the node's
  ///                  `conditions` collection.
  /// - returns: A copy of the receiver with the provided `ConditionElement`
  ///            appended to its `conditions` collection.
  public func addConditionElement(_ element: ConditionElementSyntax) -> IfStmtSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.conditions] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.conditionElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.conditions)
    return IfStmtSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `conditions` replaced.
  /// - param newChild: The new `conditions` to replace the node's
  ///                   current `conditions`, if present.
  public func withConditions(
    _ newChild: ConditionElementListSyntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.conditionElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.conditions)
    return IfStmtSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return IfStmtSyntax(root: root, data: newData)
  }
  public var elseKeyword: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.elseKeyword)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `elseKeyword` replaced.
  /// - param newChild: The new `elseKeyword` to replace the node's
  ///                   current `elseKeyword`, if present.
  public func withElseKeyword(
    _ newChild: TokenSyntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.elseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elseKeyword)
    return IfStmtSyntax(root: root, data: newData)
  }
  public var elseBody: Syntax? {
    let child = data.cachedChild(at: Cursor.elseBody)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `elseBody` replaced.
  /// - param newChild: The new `elseBody` to replace the node's
  ///                   current `elseBody`, if present.
  public func withElseBody(
    _ newChild: Syntax?) -> IfStmtSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elseBody)
    return IfStmtSyntax(root: root, data: newData)
  }

  /// Determines if two `IfStmtSyntax` nodes are equal to each other.
  public static func ==(lhs: IfStmtSyntax, rhs: IfStmtSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ElseIfContinuationSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case ifStatement
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ElseIfContinuationSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var ifStatement: IfStmtSyntax {
    let child = data.cachedChild(at: Cursor.ifStatement)
    return makeSyntax(root: _root, data: child!) as! IfStmtSyntax
  }

  /// Returns a copy of the receiver with its `ifStatement` replaced.
  /// - param newChild: The new `ifStatement` to replace the node's
  ///                   current `ifStatement`, if present.
  public func withIfStatement(
    _ newChild: IfStmtSyntax?) -> ElseIfContinuationSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.ifStmt)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ifStatement)
    return ElseIfContinuationSyntax(root: root, data: newData)
  }

  /// Determines if two `ElseIfContinuationSyntax` nodes are equal to each other.
  public static func ==(lhs: ElseIfContinuationSyntax, rhs: ElseIfContinuationSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ElseBlockSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case elseKeyword
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ElseBlockSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var elseKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.elseKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `elseKeyword` replaced.
  /// - param newChild: The new `elseKeyword` to replace the node's
  ///                   current `elseKeyword`, if present.
  public func withElseKeyword(
    _ newChild: TokenSyntax?) -> ElseBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.elseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elseKeyword)
    return ElseBlockSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> ElseBlockSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return ElseBlockSyntax(root: root, data: newData)
  }

  /// Determines if two `ElseBlockSyntax` nodes are equal to each other.
  public static func ==(lhs: ElseBlockSyntax, rhs: ElseBlockSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SwitchCaseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case unknownAttr
    case label
    case statements
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SwitchCaseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var unknownAttr: AttributeSyntax? {
    let child = data.cachedChild(at: Cursor.unknownAttr)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeSyntax
  }

  /// Returns a copy of the receiver with its `unknownAttr` replaced.
  /// - param newChild: The new `unknownAttr` to replace the node's
  ///                   current `unknownAttr`, if present.
  public func withUnknownAttr(
    _ newChild: AttributeSyntax?) -> SwitchCaseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attribute)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.unknownAttr)
    return SwitchCaseSyntax(root: root, data: newData)
  }
  public var label: Syntax {
    let child = data.cachedChild(at: Cursor.label)
    return makeSyntax(root: _root, data: child!) 
  }

  /// Returns a copy of the receiver with its `label` replaced.
  /// - param newChild: The new `label` to replace the node's
  ///                   current `label`, if present.
  public func withLabel(
    _ newChild: Syntax?) -> SwitchCaseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.unknown)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.label)
    return SwitchCaseSyntax(root: root, data: newData)
  }
  public var statements: CodeBlockItemListSyntax {
    let child = data.cachedChild(at: Cursor.statements)
    return makeSyntax(root: _root, data: child!) as! CodeBlockItemListSyntax
  }

  /// Adds the provided `CodeBlockItem` to the node's `statements`
  /// collection.
  /// - param element: The new `CodeBlockItem` to add to the node's
  ///                  `statements` collection.
  /// - returns: A copy of the receiver with the provided `CodeBlockItem`
  ///            appended to its `statements` collection.
  public func addCodeBlockItem(_ element: CodeBlockItemSyntax) -> SwitchCaseSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.statements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.codeBlockItemList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.statements)
    return SwitchCaseSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `statements` replaced.
  /// - param newChild: The new `statements` to replace the node's
  ///                   current `statements`, if present.
  public func withStatements(
    _ newChild: CodeBlockItemListSyntax?) -> SwitchCaseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlockItemList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.statements)
    return SwitchCaseSyntax(root: root, data: newData)
  }

  /// Determines if two `SwitchCaseSyntax` nodes are equal to each other.
  public static func ==(lhs: SwitchCaseSyntax, rhs: SwitchCaseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SwitchDefaultLabelSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case defaultKeyword
    case colon
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SwitchDefaultLabelSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var defaultKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.defaultKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `defaultKeyword` replaced.
  /// - param newChild: The new `defaultKeyword` to replace the node's
  ///                   current `defaultKeyword`, if present.
  public func withDefaultKeyword(
    _ newChild: TokenSyntax?) -> SwitchDefaultLabelSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.defaultKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.defaultKeyword)
    return SwitchDefaultLabelSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> SwitchDefaultLabelSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return SwitchDefaultLabelSyntax(root: root, data: newData)
  }

  /// Determines if two `SwitchDefaultLabelSyntax` nodes are equal to each other.
  public static func ==(lhs: SwitchDefaultLabelSyntax, rhs: SwitchDefaultLabelSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct CaseItemSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case pattern
    case whereClause
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `CaseItemSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> CaseItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return CaseItemSyntax(root: root, data: newData)
  }
  public var whereClause: WhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.whereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? WhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `whereClause` replaced.
  /// - param newChild: The new `whereClause` to replace the node's
  ///                   current `whereClause`, if present.
  public func withWhereClause(
    _ newChild: WhereClauseSyntax?) -> CaseItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.whereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whereClause)
    return CaseItemSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> CaseItemSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return CaseItemSyntax(root: root, data: newData)
  }

  /// Determines if two `CaseItemSyntax` nodes are equal to each other.
  public static func ==(lhs: CaseItemSyntax, rhs: CaseItemSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SwitchCaseLabelSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case caseKeyword
    case caseItems
    case colon
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SwitchCaseLabelSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var caseKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.caseKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `caseKeyword` replaced.
  /// - param newChild: The new `caseKeyword` to replace the node's
  ///                   current `caseKeyword`, if present.
  public func withCaseKeyword(
    _ newChild: TokenSyntax?) -> SwitchCaseLabelSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.caseKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.caseKeyword)
    return SwitchCaseLabelSyntax(root: root, data: newData)
  }
  public var caseItems: CaseItemListSyntax {
    let child = data.cachedChild(at: Cursor.caseItems)
    return makeSyntax(root: _root, data: child!) as! CaseItemListSyntax
  }

  /// Adds the provided `CaseItem` to the node's `caseItems`
  /// collection.
  /// - param element: The new `CaseItem` to add to the node's
  ///                  `caseItems` collection.
  /// - returns: A copy of the receiver with the provided `CaseItem`
  ///            appended to its `caseItems` collection.
  public func addCaseItem(_ element: CaseItemSyntax) -> SwitchCaseLabelSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.caseItems] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.caseItemList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.caseItems)
    return SwitchCaseLabelSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `caseItems` replaced.
  /// - param newChild: The new `caseItems` to replace the node's
  ///                   current `caseItems`, if present.
  public func withCaseItems(
    _ newChild: CaseItemListSyntax?) -> SwitchCaseLabelSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.caseItemList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.caseItems)
    return SwitchCaseLabelSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> SwitchCaseLabelSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return SwitchCaseLabelSyntax(root: root, data: newData)
  }

  /// Determines if two `SwitchCaseLabelSyntax` nodes are equal to each other.
  public static func ==(lhs: SwitchCaseLabelSyntax, rhs: SwitchCaseLabelSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct CatchClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case catchKeyword
    case pattern
    case whereClause
    case body
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `CatchClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var catchKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.catchKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `catchKeyword` replaced.
  /// - param newChild: The new `catchKeyword` to replace the node's
  ///                   current `catchKeyword`, if present.
  public func withCatchKeyword(
    _ newChild: TokenSyntax?) -> CatchClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.catchKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.catchKeyword)
    return CatchClauseSyntax(root: root, data: newData)
  }
  public var pattern: PatternSyntax? {
    let child = data.cachedChild(at: Cursor.pattern)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> CatchClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return CatchClauseSyntax(root: root, data: newData)
  }
  public var whereClause: WhereClauseSyntax? {
    let child = data.cachedChild(at: Cursor.whereClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? WhereClauseSyntax
  }

  /// Returns a copy of the receiver with its `whereClause` replaced.
  /// - param newChild: The new `whereClause` to replace the node's
  ///                   current `whereClause`, if present.
  public func withWhereClause(
    _ newChild: WhereClauseSyntax?) -> CatchClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.whereClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whereClause)
    return CatchClauseSyntax(root: root, data: newData)
  }
  public var body: CodeBlockSyntax {
    let child = data.cachedChild(at: Cursor.body)
    return makeSyntax(root: _root, data: child!) as! CodeBlockSyntax
  }

  /// Returns a copy of the receiver with its `body` replaced.
  /// - param newChild: The new `body` to replace the node's
  ///                   current `body`, if present.
  public func withBody(
    _ newChild: CodeBlockSyntax?) -> CatchClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.codeBlock)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.body)
    return CatchClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `CatchClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: CatchClauseSyntax, rhs: CatchClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct GenericWhereClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case whereKeyword
    case requirementList
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `GenericWhereClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var whereKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.whereKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `whereKeyword` replaced.
  /// - param newChild: The new `whereKeyword` to replace the node's
  ///                   current `whereKeyword`, if present.
  public func withWhereKeyword(
    _ newChild: TokenSyntax?) -> GenericWhereClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.whereKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.whereKeyword)
    return GenericWhereClauseSyntax(root: root, data: newData)
  }
  public var requirementList: GenericRequirementListSyntax {
    let child = data.cachedChild(at: Cursor.requirementList)
    return makeSyntax(root: _root, data: child!) as! GenericRequirementListSyntax
  }

  /// Adds the provided `GenericRequirement` to the node's `requirementList`
  /// collection.
  /// - param element: The new `GenericRequirement` to add to the node's
  ///                  `requirementList` collection.
  /// - returns: A copy of the receiver with the provided `GenericRequirement`
  ///            appended to its `requirementList` collection.
  public func addGenericRequirement(_ element: Syntax) -> GenericWhereClauseSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.requirementList] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.genericRequirementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.requirementList)
    return GenericWhereClauseSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `requirementList` replaced.
  /// - param newChild: The new `requirementList` to replace the node's
  ///                   current `requirementList`, if present.
  public func withRequirementList(
    _ newChild: GenericRequirementListSyntax?) -> GenericWhereClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericRequirementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.requirementList)
    return GenericWhereClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `GenericWhereClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: GenericWhereClauseSyntax, rhs: GenericWhereClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SameTypeRequirementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftTypeIdentifier
    case equalityToken
    case rightTypeIdentifier
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SameTypeRequirementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftTypeIdentifier: TypeSyntax {
    let child = data.cachedChild(at: Cursor.leftTypeIdentifier)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `leftTypeIdentifier` replaced.
  /// - param newChild: The new `leftTypeIdentifier` to replace the node's
  ///                   current `leftTypeIdentifier`, if present.
  public func withLeftTypeIdentifier(
    _ newChild: TypeSyntax?) -> SameTypeRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftTypeIdentifier)
    return SameTypeRequirementSyntax(root: root, data: newData)
  }
  public var equalityToken: TokenSyntax {
    let child = data.cachedChild(at: Cursor.equalityToken)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `equalityToken` replaced.
  /// - param newChild: The new `equalityToken` to replace the node's
  ///                   current `equalityToken`, if present.
  public func withEqualityToken(
    _ newChild: TokenSyntax?) -> SameTypeRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.spacedBinaryOperator(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.equalityToken)
    return SameTypeRequirementSyntax(root: root, data: newData)
  }
  public var rightTypeIdentifier: TypeSyntax {
    let child = data.cachedChild(at: Cursor.rightTypeIdentifier)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `rightTypeIdentifier` replaced.
  /// - param newChild: The new `rightTypeIdentifier` to replace the node's
  ///                   current `rightTypeIdentifier`, if present.
  public func withRightTypeIdentifier(
    _ newChild: TypeSyntax?) -> SameTypeRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightTypeIdentifier)
    return SameTypeRequirementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> SameTypeRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return SameTypeRequirementSyntax(root: root, data: newData)
  }

  /// Determines if two `SameTypeRequirementSyntax` nodes are equal to each other.
  public static func ==(lhs: SameTypeRequirementSyntax, rhs: SameTypeRequirementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct GenericParameterSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case attributes
    case name
    case colon
    case inheritedType
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `GenericParameterSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> GenericParameterSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return GenericParameterSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> GenericParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return GenericParameterSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> GenericParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return GenericParameterSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> GenericParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return GenericParameterSyntax(root: root, data: newData)
  }
  public var inheritedType: TypeSyntax? {
    let child = data.cachedChild(at: Cursor.inheritedType)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeSyntax
  }

  /// Returns a copy of the receiver with its `inheritedType` replaced.
  /// - param newChild: The new `inheritedType` to replace the node's
  ///                   current `inheritedType`, if present.
  public func withInheritedType(
    _ newChild: TypeSyntax?) -> GenericParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inheritedType)
    return GenericParameterSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> GenericParameterSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return GenericParameterSyntax(root: root, data: newData)
  }

  /// Determines if two `GenericParameterSyntax` nodes are equal to each other.
  public static func ==(lhs: GenericParameterSyntax, rhs: GenericParameterSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct GenericParameterClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftAngleBracket
    case genericParameterList
    case rightAngleBracket
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `GenericParameterClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftAngleBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftAngleBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftAngleBracket` replaced.
  /// - param newChild: The new `leftAngleBracket` to replace the node's
  ///                   current `leftAngleBracket`, if present.
  public func withLeftAngleBracket(
    _ newChild: TokenSyntax?) -> GenericParameterClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftAngle)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftAngleBracket)
    return GenericParameterClauseSyntax(root: root, data: newData)
  }
  public var genericParameterList: GenericParameterListSyntax {
    let child = data.cachedChild(at: Cursor.genericParameterList)
    return makeSyntax(root: _root, data: child!) as! GenericParameterListSyntax
  }

  /// Adds the provided `GenericParameter` to the node's `genericParameterList`
  /// collection.
  /// - param element: The new `GenericParameter` to add to the node's
  ///                  `genericParameterList` collection.
  /// - returns: A copy of the receiver with the provided `GenericParameter`
  ///            appended to its `genericParameterList` collection.
  public func addGenericParameter(_ element: GenericParameterSyntax) -> GenericParameterClauseSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.genericParameterList] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.genericParameterList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.genericParameterList)
    return GenericParameterClauseSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `genericParameterList` replaced.
  /// - param newChild: The new `genericParameterList` to replace the node's
  ///                   current `genericParameterList`, if present.
  public func withGenericParameterList(
    _ newChild: GenericParameterListSyntax?) -> GenericParameterClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericParameterList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericParameterList)
    return GenericParameterClauseSyntax(root: root, data: newData)
  }
  public var rightAngleBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightAngleBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightAngleBracket` replaced.
  /// - param newChild: The new `rightAngleBracket` to replace the node's
  ///                   current `rightAngleBracket`, if present.
  public func withRightAngleBracket(
    _ newChild: TokenSyntax?) -> GenericParameterClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightAngle)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightAngleBracket)
    return GenericParameterClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `GenericParameterClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: GenericParameterClauseSyntax, rhs: GenericParameterClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ConformanceRequirementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftTypeIdentifier
    case colon
    case rightTypeIdentifier
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ConformanceRequirementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftTypeIdentifier: TypeSyntax {
    let child = data.cachedChild(at: Cursor.leftTypeIdentifier)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `leftTypeIdentifier` replaced.
  /// - param newChild: The new `leftTypeIdentifier` to replace the node's
  ///                   current `leftTypeIdentifier`, if present.
  public func withLeftTypeIdentifier(
    _ newChild: TypeSyntax?) -> ConformanceRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftTypeIdentifier)
    return ConformanceRequirementSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> ConformanceRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return ConformanceRequirementSyntax(root: root, data: newData)
  }
  public var rightTypeIdentifier: TypeSyntax {
    let child = data.cachedChild(at: Cursor.rightTypeIdentifier)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `rightTypeIdentifier` replaced.
  /// - param newChild: The new `rightTypeIdentifier` to replace the node's
  ///                   current `rightTypeIdentifier`, if present.
  public func withRightTypeIdentifier(
    _ newChild: TypeSyntax?) -> ConformanceRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightTypeIdentifier)
    return ConformanceRequirementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> ConformanceRequirementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return ConformanceRequirementSyntax(root: root, data: newData)
  }

  /// Determines if two `ConformanceRequirementSyntax` nodes are equal to each other.
  public static func ==(lhs: ConformanceRequirementSyntax, rhs: ConformanceRequirementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct SimpleTypeIdentifierSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case name
    case genericArgumentClause
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `SimpleTypeIdentifierSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> SimpleTypeIdentifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return SimpleTypeIdentifierSyntax(root: root, data: newData)
  }
  public var genericArgumentClause: GenericArgumentClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericArgumentClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericArgumentClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericArgumentClause` replaced.
  /// - param newChild: The new `genericArgumentClause` to replace the node's
  ///                   current `genericArgumentClause`, if present.
  public func withGenericArgumentClause(
    _ newChild: GenericArgumentClauseSyntax?) -> SimpleTypeIdentifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericArgumentClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericArgumentClause)
    return SimpleTypeIdentifierSyntax(root: root, data: newData)
  }

  /// Determines if two `SimpleTypeIdentifierSyntax` nodes are equal to each other.
  public static func ==(lhs: SimpleTypeIdentifierSyntax, rhs: SimpleTypeIdentifierSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct MemberTypeIdentifierSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case baseType
    case period
    case name
    case genericArgumentClause
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `MemberTypeIdentifierSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var baseType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.baseType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `baseType` replaced.
  /// - param newChild: The new `baseType` to replace the node's
  ///                   current `baseType`, if present.
  public func withBaseType(
    _ newChild: TypeSyntax?) -> MemberTypeIdentifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.baseType)
    return MemberTypeIdentifierSyntax(root: root, data: newData)
  }
  public var period: TokenSyntax {
    let child = data.cachedChild(at: Cursor.period)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `period` replaced.
  /// - param newChild: The new `period` to replace the node's
  ///                   current `period`, if present.
  public func withPeriod(
    _ newChild: TokenSyntax?) -> MemberTypeIdentifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.period)
    return MemberTypeIdentifierSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax {
    let child = data.cachedChild(at: Cursor.name)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> MemberTypeIdentifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return MemberTypeIdentifierSyntax(root: root, data: newData)
  }
  public var genericArgumentClause: GenericArgumentClauseSyntax? {
    let child = data.cachedChild(at: Cursor.genericArgumentClause)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? GenericArgumentClauseSyntax
  }

  /// Returns a copy of the receiver with its `genericArgumentClause` replaced.
  /// - param newChild: The new `genericArgumentClause` to replace the node's
  ///                   current `genericArgumentClause`, if present.
  public func withGenericArgumentClause(
    _ newChild: GenericArgumentClauseSyntax?) -> MemberTypeIdentifierSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericArgumentClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.genericArgumentClause)
    return MemberTypeIdentifierSyntax(root: root, data: newData)
  }

  /// Determines if two `MemberTypeIdentifierSyntax` nodes are equal to each other.
  public static func ==(lhs: MemberTypeIdentifierSyntax, rhs: MemberTypeIdentifierSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ArrayTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftSquareBracket
    case elementType
    case rightSquareBracket
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ArrayTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftSquareBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftSquareBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftSquareBracket` replaced.
  /// - param newChild: The new `leftSquareBracket` to replace the node's
  ///                   current `leftSquareBracket`, if present.
  public func withLeftSquareBracket(
    _ newChild: TokenSyntax?) -> ArrayTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftSquareBracket)
    return ArrayTypeSyntax(root: root, data: newData)
  }
  public var elementType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.elementType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `elementType` replaced.
  /// - param newChild: The new `elementType` to replace the node's
  ///                   current `elementType`, if present.
  public func withElementType(
    _ newChild: TypeSyntax?) -> ArrayTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elementType)
    return ArrayTypeSyntax(root: root, data: newData)
  }
  public var rightSquareBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightSquareBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightSquareBracket` replaced.
  /// - param newChild: The new `rightSquareBracket` to replace the node's
  ///                   current `rightSquareBracket`, if present.
  public func withRightSquareBracket(
    _ newChild: TokenSyntax?) -> ArrayTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightSquareBracket)
    return ArrayTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `ArrayTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: ArrayTypeSyntax, rhs: ArrayTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct DictionaryTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftSquareBracket
    case keyType
    case colon
    case valueType
    case rightSquareBracket
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `DictionaryTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftSquareBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftSquareBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftSquareBracket` replaced.
  /// - param newChild: The new `leftSquareBracket` to replace the node's
  ///                   current `leftSquareBracket`, if present.
  public func withLeftSquareBracket(
    _ newChild: TokenSyntax?) -> DictionaryTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftSquareBracket)
    return DictionaryTypeSyntax(root: root, data: newData)
  }
  public var keyType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.keyType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `keyType` replaced.
  /// - param newChild: The new `keyType` to replace the node's
  ///                   current `keyType`, if present.
  public func withKeyType(
    _ newChild: TypeSyntax?) -> DictionaryTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.keyType)
    return DictionaryTypeSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> DictionaryTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return DictionaryTypeSyntax(root: root, data: newData)
  }
  public var valueType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.valueType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `valueType` replaced.
  /// - param newChild: The new `valueType` to replace the node's
  ///                   current `valueType`, if present.
  public func withValueType(
    _ newChild: TypeSyntax?) -> DictionaryTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.valueType)
    return DictionaryTypeSyntax(root: root, data: newData)
  }
  public var rightSquareBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightSquareBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightSquareBracket` replaced.
  /// - param newChild: The new `rightSquareBracket` to replace the node's
  ///                   current `rightSquareBracket`, if present.
  public func withRightSquareBracket(
    _ newChild: TokenSyntax?) -> DictionaryTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightSquareBracket)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightSquareBracket)
    return DictionaryTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `DictionaryTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: DictionaryTypeSyntax, rhs: DictionaryTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct MetatypeTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case baseType
    case period
    case typeOrProtocol
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `MetatypeTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var baseType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.baseType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `baseType` replaced.
  /// - param newChild: The new `baseType` to replace the node's
  ///                   current `baseType`, if present.
  public func withBaseType(
    _ newChild: TypeSyntax?) -> MetatypeTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.baseType)
    return MetatypeTypeSyntax(root: root, data: newData)
  }
  public var period: TokenSyntax {
    let child = data.cachedChild(at: Cursor.period)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `period` replaced.
  /// - param newChild: The new `period` to replace the node's
  ///                   current `period`, if present.
  public func withPeriod(
    _ newChild: TokenSyntax?) -> MetatypeTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.period)
    return MetatypeTypeSyntax(root: root, data: newData)
  }
  public var typeOrProtocol: TokenSyntax {
    let child = data.cachedChild(at: Cursor.typeOrProtocol)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `typeOrProtocol` replaced.
  /// - param newChild: The new `typeOrProtocol` to replace the node's
  ///                   current `typeOrProtocol`, if present.
  public func withTypeOrProtocol(
    _ newChild: TokenSyntax?) -> MetatypeTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeOrProtocol)
    return MetatypeTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `MetatypeTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: MetatypeTypeSyntax, rhs: MetatypeTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct OptionalTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case wrappedType
    case questionMark
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `OptionalTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var wrappedType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.wrappedType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `wrappedType` replaced.
  /// - param newChild: The new `wrappedType` to replace the node's
  ///                   current `wrappedType`, if present.
  public func withWrappedType(
    _ newChild: TypeSyntax?) -> OptionalTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.wrappedType)
    return OptionalTypeSyntax(root: root, data: newData)
  }
  public var questionMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.questionMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `questionMark` replaced.
  /// - param newChild: The new `questionMark` to replace the node's
  ///                   current `questionMark`, if present.
  public func withQuestionMark(
    _ newChild: TokenSyntax?) -> OptionalTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.questionMark)
    return OptionalTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `OptionalTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: OptionalTypeSyntax, rhs: OptionalTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ImplicitlyUnwrappedOptionalTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case wrappedType
    case exclamationMark
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ImplicitlyUnwrappedOptionalTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var wrappedType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.wrappedType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `wrappedType` replaced.
  /// - param newChild: The new `wrappedType` to replace the node's
  ///                   current `wrappedType`, if present.
  public func withWrappedType(
    _ newChild: TypeSyntax?) -> ImplicitlyUnwrappedOptionalTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.wrappedType)
    return ImplicitlyUnwrappedOptionalTypeSyntax(root: root, data: newData)
  }
  public var exclamationMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.exclamationMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `exclamationMark` replaced.
  /// - param newChild: The new `exclamationMark` to replace the node's
  ///                   current `exclamationMark`, if present.
  public func withExclamationMark(
    _ newChild: TokenSyntax?) -> ImplicitlyUnwrappedOptionalTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.exclamationMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.exclamationMark)
    return ImplicitlyUnwrappedOptionalTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `ImplicitlyUnwrappedOptionalTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: ImplicitlyUnwrappedOptionalTypeSyntax, rhs: ImplicitlyUnwrappedOptionalTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct CompositionTypeElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case type
    case ampersand
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `CompositionTypeElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var type: TypeSyntax {
    let child = data.cachedChild(at: Cursor.type)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> CompositionTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return CompositionTypeElementSyntax(root: root, data: newData)
  }
  public var ampersand: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.ampersand)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `ampersand` replaced.
  /// - param newChild: The new `ampersand` to replace the node's
  ///                   current `ampersand`, if present.
  public func withAmpersand(
    _ newChild: TokenSyntax?) -> CompositionTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ampersand)
    return CompositionTypeElementSyntax(root: root, data: newData)
  }

  /// Determines if two `CompositionTypeElementSyntax` nodes are equal to each other.
  public static func ==(lhs: CompositionTypeElementSyntax, rhs: CompositionTypeElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct CompositionTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case elements
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `CompositionTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var elements: CompositionTypeElementListSyntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) as! CompositionTypeElementListSyntax
  }

  /// Adds the provided `CompositionTypeElement` to the node's `elements`
  /// collection.
  /// - param element: The new `CompositionTypeElement` to add to the node's
  ///                  `elements` collection.
  /// - returns: A copy of the receiver with the provided `CompositionTypeElement`
  ///            appended to its `elements` collection.
  public func addCompositionTypeElement(_ element: CompositionTypeElementSyntax) -> CompositionTypeSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.compositionTypeElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elements)
    return CompositionTypeSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: CompositionTypeElementListSyntax?) -> CompositionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.compositionTypeElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return CompositionTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `CompositionTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: CompositionTypeSyntax, rhs: CompositionTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TupleTypeElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case inOut
    case name
    case secondName
    case colon
    case type
    case ellipsis
    case initializer
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TupleTypeElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var inOut: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.inOut)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `inOut` replaced.
  /// - param newChild: The new `inOut` to replace the node's
  ///                   current `inOut`, if present.
  public func withInOut(
    _ newChild: TokenSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.inOut)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var name: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.name)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `name` replaced.
  /// - param newChild: The new `name` to replace the node's
  ///                   current `name`, if present.
  public func withName(
    _ newChild: TokenSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.name)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var secondName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.secondName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `secondName` replaced.
  /// - param newChild: The new `secondName` to replace the node's
  ///                   current `secondName`, if present.
  public func withSecondName(
    _ newChild: TokenSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.secondName)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var colon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.colon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var type: TypeSyntax {
    let child = data.cachedChild(at: Cursor.type)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var ellipsis: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.ellipsis)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `ellipsis` replaced.
  /// - param newChild: The new `ellipsis` to replace the node's
  ///                   current `ellipsis`, if present.
  public func withEllipsis(
    _ newChild: TokenSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.ellipsis)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var initializer: InitializerClauseSyntax? {
    let child = data.cachedChild(at: Cursor.initializer)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? InitializerClauseSyntax
  }

  /// Returns a copy of the receiver with its `initializer` replaced.
  /// - param newChild: The new `initializer` to replace the node's
  ///                   current `initializer`, if present.
  public func withInitializer(
    _ newChild: InitializerClauseSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.initializerClause)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.initializer)
    return TupleTypeElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> TupleTypeElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return TupleTypeElementSyntax(root: root, data: newData)
  }

  /// Determines if two `TupleTypeElementSyntax` nodes are equal to each other.
  public static func ==(lhs: TupleTypeElementSyntax, rhs: TupleTypeElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TupleTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case elements
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TupleTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> TupleTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return TupleTypeSyntax(root: root, data: newData)
  }
  public var elements: TupleTypeElementListSyntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) as! TupleTypeElementListSyntax
  }

  /// Adds the provided `TupleTypeElement` to the node's `elements`
  /// collection.
  /// - param element: The new `TupleTypeElement` to add to the node's
  ///                  `elements` collection.
  /// - returns: A copy of the receiver with the provided `TupleTypeElement`
  ///            appended to its `elements` collection.
  public func addTupleTypeElement(_ element: TupleTypeElementSyntax) -> TupleTypeSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tupleTypeElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elements)
    return TupleTypeSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: TupleTypeElementListSyntax?) -> TupleTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.tupleTypeElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return TupleTypeSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> TupleTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return TupleTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `TupleTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: TupleTypeSyntax, rhs: TupleTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct FunctionTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case arguments
    case rightParen
    case throwsOrRethrowsKeyword
    case arrow
    case returnType
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `FunctionTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> FunctionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return FunctionTypeSyntax(root: root, data: newData)
  }
  public var arguments: TupleTypeElementListSyntax {
    let child = data.cachedChild(at: Cursor.arguments)
    return makeSyntax(root: _root, data: child!) as! TupleTypeElementListSyntax
  }

  /// Adds the provided `TupleTypeElement` to the node's `arguments`
  /// collection.
  /// - param element: The new `TupleTypeElement` to add to the node's
  ///                  `arguments` collection.
  /// - returns: A copy of the receiver with the provided `TupleTypeElement`
  ///            appended to its `arguments` collection.
  public func addTupleTypeElement(_ element: TupleTypeElementSyntax) -> FunctionTypeSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.arguments] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tupleTypeElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.arguments)
    return FunctionTypeSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `arguments` replaced.
  /// - param newChild: The new `arguments` to replace the node's
  ///                   current `arguments`, if present.
  public func withArguments(
    _ newChild: TupleTypeElementListSyntax?) -> FunctionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.tupleTypeElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arguments)
    return FunctionTypeSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> FunctionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return FunctionTypeSyntax(root: root, data: newData)
  }
  public var throwsOrRethrowsKeyword: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.throwsOrRethrowsKeyword)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `throwsOrRethrowsKeyword` replaced.
  /// - param newChild: The new `throwsOrRethrowsKeyword` to replace the node's
  ///                   current `throwsOrRethrowsKeyword`, if present.
  public func withThrowsOrRethrowsKeyword(
    _ newChild: TokenSyntax?) -> FunctionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.throwsKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.throwsOrRethrowsKeyword)
    return FunctionTypeSyntax(root: root, data: newData)
  }
  public var arrow: TokenSyntax {
    let child = data.cachedChild(at: Cursor.arrow)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `arrow` replaced.
  /// - param newChild: The new `arrow` to replace the node's
  ///                   current `arrow`, if present.
  public func withArrow(
    _ newChild: TokenSyntax?) -> FunctionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.arrow)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arrow)
    return FunctionTypeSyntax(root: root, data: newData)
  }
  public var returnType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.returnType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `returnType` replaced.
  /// - param newChild: The new `returnType` to replace the node's
  ///                   current `returnType`, if present.
  public func withReturnType(
    _ newChild: TypeSyntax?) -> FunctionTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.returnType)
    return FunctionTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `FunctionTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: FunctionTypeSyntax, rhs: FunctionTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AttributedTypeSyntax: TypeSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case specifier
    case attributes
    case baseType
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AttributedTypeSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var specifier: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.specifier)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `specifier` replaced.
  /// - param newChild: The new `specifier` to replace the node's
  ///                   current `specifier`, if present.
  public func withSpecifier(
    _ newChild: TokenSyntax?) -> AttributedTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.unknown(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.specifier)
    return AttributedTypeSyntax(root: root, data: newData)
  }
  public var attributes: AttributeListSyntax? {
    let child = data.cachedChild(at: Cursor.attributes)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? AttributeListSyntax
  }

  /// Adds the provided `Attribute` to the node's `attributes`
  /// collection.
  /// - param element: The new `Attribute` to add to the node's
  ///                  `attributes` collection.
  /// - returns: A copy of the receiver with the provided `Attribute`
  ///            appended to its `attributes` collection.
  public func addAttribute(_ element: AttributeSyntax) -> AttributedTypeSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.attributes] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.attributeList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.attributes)
    return AttributedTypeSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `attributes` replaced.
  /// - param newChild: The new `attributes` to replace the node's
  ///                   current `attributes`, if present.
  public func withAttributes(
    _ newChild: AttributeListSyntax?) -> AttributedTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.attributeList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.attributes)
    return AttributedTypeSyntax(root: root, data: newData)
  }
  public var baseType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.baseType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `baseType` replaced.
  /// - param newChild: The new `baseType` to replace the node's
  ///                   current `baseType`, if present.
  public func withBaseType(
    _ newChild: TypeSyntax?) -> AttributedTypeSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.baseType)
    return AttributedTypeSyntax(root: root, data: newData)
  }

  /// Determines if two `AttributedTypeSyntax` nodes are equal to each other.
  public static func ==(lhs: AttributedTypeSyntax, rhs: AttributedTypeSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct GenericArgumentSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case argumentType
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `GenericArgumentSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var argumentType: TypeSyntax {
    let child = data.cachedChild(at: Cursor.argumentType)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `argumentType` replaced.
  /// - param newChild: The new `argumentType` to replace the node's
  ///                   current `argumentType`, if present.
  public func withArgumentType(
    _ newChild: TypeSyntax?) -> GenericArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.argumentType)
    return GenericArgumentSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> GenericArgumentSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return GenericArgumentSyntax(root: root, data: newData)
  }

  /// Determines if two `GenericArgumentSyntax` nodes are equal to each other.
  public static func ==(lhs: GenericArgumentSyntax, rhs: GenericArgumentSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct GenericArgumentClauseSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftAngleBracket
    case arguments
    case rightAngleBracket
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `GenericArgumentClauseSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftAngleBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftAngleBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftAngleBracket` replaced.
  /// - param newChild: The new `leftAngleBracket` to replace the node's
  ///                   current `leftAngleBracket`, if present.
  public func withLeftAngleBracket(
    _ newChild: TokenSyntax?) -> GenericArgumentClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftAngle)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftAngleBracket)
    return GenericArgumentClauseSyntax(root: root, data: newData)
  }
  public var arguments: GenericArgumentListSyntax {
    let child = data.cachedChild(at: Cursor.arguments)
    return makeSyntax(root: _root, data: child!) as! GenericArgumentListSyntax
  }

  /// Adds the provided `GenericArgument` to the node's `arguments`
  /// collection.
  /// - param element: The new `GenericArgument` to add to the node's
  ///                  `arguments` collection.
  /// - returns: A copy of the receiver with the provided `GenericArgument`
  ///            appended to its `arguments` collection.
  public func addGenericArgument(_ element: GenericArgumentSyntax) -> GenericArgumentClauseSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.arguments] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.genericArgumentList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.arguments)
    return GenericArgumentClauseSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `arguments` replaced.
  /// - param newChild: The new `arguments` to replace the node's
  ///                   current `arguments`, if present.
  public func withArguments(
    _ newChild: GenericArgumentListSyntax?) -> GenericArgumentClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.genericArgumentList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.arguments)
    return GenericArgumentClauseSyntax(root: root, data: newData)
  }
  public var rightAngleBracket: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightAngleBracket)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightAngleBracket` replaced.
  /// - param newChild: The new `rightAngleBracket` to replace the node's
  ///                   current `rightAngleBracket`, if present.
  public func withRightAngleBracket(
    _ newChild: TokenSyntax?) -> GenericArgumentClauseSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightAngle)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightAngleBracket)
    return GenericArgumentClauseSyntax(root: root, data: newData)
  }

  /// Determines if two `GenericArgumentClauseSyntax` nodes are equal to each other.
  public static func ==(lhs: GenericArgumentClauseSyntax, rhs: GenericArgumentClauseSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TypeAnnotationSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case colon
    case type
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TypeAnnotationSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var colon: TokenSyntax {
    let child = data.cachedChild(at: Cursor.colon)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `colon` replaced.
  /// - param newChild: The new `colon` to replace the node's
  ///                   current `colon`, if present.
  public func withColon(
    _ newChild: TokenSyntax?) -> TypeAnnotationSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.colon)
    return TypeAnnotationSyntax(root: root, data: newData)
  }
  public var type: TypeSyntax {
    let child = data.cachedChild(at: Cursor.type)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> TypeAnnotationSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return TypeAnnotationSyntax(root: root, data: newData)
  }

  /// Determines if two `TypeAnnotationSyntax` nodes are equal to each other.
  public static func ==(lhs: TypeAnnotationSyntax, rhs: TypeAnnotationSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct EnumCasePatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case type
    case period
    case caseName
    case associatedTuple
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `EnumCasePatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var type: TypeSyntax? {
    let child = data.cachedChild(at: Cursor.type)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> EnumCasePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return EnumCasePatternSyntax(root: root, data: newData)
  }
  public var period: TokenSyntax {
    let child = data.cachedChild(at: Cursor.period)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `period` replaced.
  /// - param newChild: The new `period` to replace the node's
  ///                   current `period`, if present.
  public func withPeriod(
    _ newChild: TokenSyntax?) -> EnumCasePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.period)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.period)
    return EnumCasePatternSyntax(root: root, data: newData)
  }
  public var caseName: TokenSyntax {
    let child = data.cachedChild(at: Cursor.caseName)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `caseName` replaced.
  /// - param newChild: The new `caseName` to replace the node's
  ///                   current `caseName`, if present.
  public func withCaseName(
    _ newChild: TokenSyntax?) -> EnumCasePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.caseName)
    return EnumCasePatternSyntax(root: root, data: newData)
  }
  public var associatedTuple: TuplePatternSyntax? {
    let child = data.cachedChild(at: Cursor.associatedTuple)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TuplePatternSyntax
  }

  /// Returns a copy of the receiver with its `associatedTuple` replaced.
  /// - param newChild: The new `associatedTuple` to replace the node's
  ///                   current `associatedTuple`, if present.
  public func withAssociatedTuple(
    _ newChild: TuplePatternSyntax?) -> EnumCasePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.tuplePattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.associatedTuple)
    return EnumCasePatternSyntax(root: root, data: newData)
  }

  /// Determines if two `EnumCasePatternSyntax` nodes are equal to each other.
  public static func ==(lhs: EnumCasePatternSyntax, rhs: EnumCasePatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IsTypePatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case isKeyword
    case type
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IsTypePatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var isKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.isKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `isKeyword` replaced.
  /// - param newChild: The new `isKeyword` to replace the node's
  ///                   current `isKeyword`, if present.
  public func withIsKeyword(
    _ newChild: TokenSyntax?) -> IsTypePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.isKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.isKeyword)
    return IsTypePatternSyntax(root: root, data: newData)
  }
  public var type: TypeSyntax {
    let child = data.cachedChild(at: Cursor.type)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> IsTypePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return IsTypePatternSyntax(root: root, data: newData)
  }

  /// Determines if two `IsTypePatternSyntax` nodes are equal to each other.
  public static func ==(lhs: IsTypePatternSyntax, rhs: IsTypePatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct OptionalPatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case subPattern
    case questionMark
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `OptionalPatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var subPattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.subPattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `subPattern` replaced.
  /// - param newChild: The new `subPattern` to replace the node's
  ///                   current `subPattern`, if present.
  public func withSubPattern(
    _ newChild: PatternSyntax?) -> OptionalPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.subPattern)
    return OptionalPatternSyntax(root: root, data: newData)
  }
  public var questionMark: TokenSyntax {
    let child = data.cachedChild(at: Cursor.questionMark)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `questionMark` replaced.
  /// - param newChild: The new `questionMark` to replace the node's
  ///                   current `questionMark`, if present.
  public func withQuestionMark(
    _ newChild: TokenSyntax?) -> OptionalPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.postfixQuestionMark)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.questionMark)
    return OptionalPatternSyntax(root: root, data: newData)
  }

  /// Determines if two `OptionalPatternSyntax` nodes are equal to each other.
  public static func ==(lhs: OptionalPatternSyntax, rhs: OptionalPatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct IdentifierPatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case identifier
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `IdentifierPatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var identifier: TokenSyntax {
    let child = data.cachedChild(at: Cursor.identifier)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `identifier` replaced.
  /// - param newChild: The new `identifier` to replace the node's
  ///                   current `identifier`, if present.
  public func withIdentifier(
    _ newChild: TokenSyntax?) -> IdentifierPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.identifier)
    return IdentifierPatternSyntax(root: root, data: newData)
  }

  /// Determines if two `IdentifierPatternSyntax` nodes are equal to each other.
  public static func ==(lhs: IdentifierPatternSyntax, rhs: IdentifierPatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct AsTypePatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case pattern
    case asKeyword
    case type
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `AsTypePatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> AsTypePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return AsTypePatternSyntax(root: root, data: newData)
  }
  public var asKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.asKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `asKeyword` replaced.
  /// - param newChild: The new `asKeyword` to replace the node's
  ///                   current `asKeyword`, if present.
  public func withAsKeyword(
    _ newChild: TokenSyntax?) -> AsTypePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.asKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.asKeyword)
    return AsTypePatternSyntax(root: root, data: newData)
  }
  public var type: TypeSyntax {
    let child = data.cachedChild(at: Cursor.type)
    return makeSyntax(root: _root, data: child!) as! TypeSyntax
  }

  /// Returns a copy of the receiver with its `type` replaced.
  /// - param newChild: The new `type` to replace the node's
  ///                   current `type`, if present.
  public func withType(
    _ newChild: TypeSyntax?) -> AsTypePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.type)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.type)
    return AsTypePatternSyntax(root: root, data: newData)
  }

  /// Determines if two `AsTypePatternSyntax` nodes are equal to each other.
  public static func ==(lhs: AsTypePatternSyntax, rhs: AsTypePatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TuplePatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case leftParen
    case elements
    case rightParen
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TuplePatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var leftParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.leftParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `leftParen` replaced.
  /// - param newChild: The new `leftParen` to replace the node's
  ///                   current `leftParen`, if present.
  public func withLeftParen(
    _ newChild: TokenSyntax?) -> TuplePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.leftParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.leftParen)
    return TuplePatternSyntax(root: root, data: newData)
  }
  public var elements: TuplePatternElementListSyntax {
    let child = data.cachedChild(at: Cursor.elements)
    return makeSyntax(root: _root, data: child!) as! TuplePatternElementListSyntax
  }

  /// Adds the provided `TuplePatternElement` to the node's `elements`
  /// collection.
  /// - param element: The new `TuplePatternElement` to add to the node's
  ///                  `elements` collection.
  /// - returns: A copy of the receiver with the provided `TuplePatternElement`
  ///            appended to its `elements` collection.
  public func addTuplePatternElement(_ element: TuplePatternElementSyntax) -> TuplePatternSyntax {
    var collection: RawSyntax
    if let col = raw[Cursor.elements] {
      collection = col.appending(element.raw)
    } else {
      collection = RawSyntax(kind: SyntaxKind.tuplePatternElementList,
                             layout: [element.raw], presence: .present)
    }
    let (root, newData) = data.replacingChild(collection,
                                              at: Cursor.elements)
    return TuplePatternSyntax(root: root, data: newData)
  }

  /// Returns a copy of the receiver with its `elements` replaced.
  /// - param newChild: The new `elements` to replace the node's
  ///                   current `elements`, if present.
  public func withElements(
    _ newChild: TuplePatternElementListSyntax?) -> TuplePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.tuplePatternElementList)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.elements)
    return TuplePatternSyntax(root: root, data: newData)
  }
  public var rightParen: TokenSyntax {
    let child = data.cachedChild(at: Cursor.rightParen)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `rightParen` replaced.
  /// - param newChild: The new `rightParen` to replace the node's
  ///                   current `rightParen`, if present.
  public func withRightParen(
    _ newChild: TokenSyntax?) -> TuplePatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.rightParen)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.rightParen)
    return TuplePatternSyntax(root: root, data: newData)
  }

  /// Determines if two `TuplePatternSyntax` nodes are equal to each other.
  public static func ==(lhs: TuplePatternSyntax, rhs: TuplePatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct WildcardPatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case wildcard
    case typeAnnotation
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `WildcardPatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var wildcard: TokenSyntax {
    let child = data.cachedChild(at: Cursor.wildcard)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `wildcard` replaced.
  /// - param newChild: The new `wildcard` to replace the node's
  ///                   current `wildcard`, if present.
  public func withWildcard(
    _ newChild: TokenSyntax?) -> WildcardPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.wildcardKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.wildcard)
    return WildcardPatternSyntax(root: root, data: newData)
  }
  public var typeAnnotation: TypeAnnotationSyntax? {
    let child = data.cachedChild(at: Cursor.typeAnnotation)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TypeAnnotationSyntax
  }

  /// Returns a copy of the receiver with its `typeAnnotation` replaced.
  /// - param newChild: The new `typeAnnotation` to replace the node's
  ///                   current `typeAnnotation`, if present.
  public func withTypeAnnotation(
    _ newChild: TypeAnnotationSyntax?) -> WildcardPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.typeAnnotation)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.typeAnnotation)
    return WildcardPatternSyntax(root: root, data: newData)
  }

  /// Determines if two `WildcardPatternSyntax` nodes are equal to each other.
  public static func ==(lhs: WildcardPatternSyntax, rhs: WildcardPatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct TuplePatternElementSyntax: Syntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case labelName
    case labelColon
    case pattern
    case trailingComma
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `TuplePatternElementSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var labelName: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelName)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelName` replaced.
  /// - param newChild: The new `labelName` to replace the node's
  ///                   current `labelName`, if present.
  public func withLabelName(
    _ newChild: TokenSyntax?) -> TuplePatternElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.identifier(""))
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelName)
    return TuplePatternElementSyntax(root: root, data: newData)
  }
  public var labelColon: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.labelColon)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `labelColon` replaced.
  /// - param newChild: The new `labelColon` to replace the node's
  ///                   current `labelColon`, if present.
  public func withLabelColon(
    _ newChild: TokenSyntax?) -> TuplePatternElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.colon)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.labelColon)
    return TuplePatternElementSyntax(root: root, data: newData)
  }
  public var pattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.pattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `pattern` replaced.
  /// - param newChild: The new `pattern` to replace the node's
  ///                   current `pattern`, if present.
  public func withPattern(
    _ newChild: PatternSyntax?) -> TuplePatternElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.pattern)
    return TuplePatternElementSyntax(root: root, data: newData)
  }
  public var trailingComma: TokenSyntax? {
    let child = data.cachedChild(at: Cursor.trailingComma)
    if child == nil { return nil }
    return makeSyntax(root: _root, data: child!) as? TokenSyntax
  }

  /// Returns a copy of the receiver with its `trailingComma` replaced.
  /// - param newChild: The new `trailingComma` to replace the node's
  ///                   current `trailingComma`, if present.
  public func withTrailingComma(
    _ newChild: TokenSyntax?) -> TuplePatternElementSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.comma)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.trailingComma)
    return TuplePatternElementSyntax(root: root, data: newData)
  }

  /// Determines if two `TuplePatternElementSyntax` nodes are equal to each other.
  public static func ==(lhs: TuplePatternElementSyntax, rhs: TuplePatternElementSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ExpressionPatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case expression
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ExpressionPatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var expression: ExprSyntax {
    let child = data.cachedChild(at: Cursor.expression)
    return makeSyntax(root: _root, data: child!) as! ExprSyntax
  }

  /// Returns a copy of the receiver with its `expression` replaced.
  /// - param newChild: The new `expression` to replace the node's
  ///                   current `expression`, if present.
  public func withExpression(
    _ newChild: ExprSyntax?) -> ExpressionPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.expr)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.expression)
    return ExpressionPatternSyntax(root: root, data: newData)
  }

  /// Determines if two `ExpressionPatternSyntax` nodes are equal to each other.
  public static func ==(lhs: ExpressionPatternSyntax, rhs: ExpressionPatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public struct ValueBindingPatternSyntax: PatternSyntax, _SyntaxBase, Hashable {
  enum Cursor: Int {
    case letOrVarKeyword
    case valuePattern
  }

  let _root: SyntaxData
  unowned let _data: SyntaxData 

  /// Creates a `ValueBindingPatternSyntax` node from the provided root and data.
  internal init(root: SyntaxData, data: SyntaxData) {
    self._root = root
    self._data = data
  }

  public var letOrVarKeyword: TokenSyntax {
    let child = data.cachedChild(at: Cursor.letOrVarKeyword)
    return makeSyntax(root: _root, data: child!) as! TokenSyntax
  }

  /// Returns a copy of the receiver with its `letOrVarKeyword` replaced.
  /// - param newChild: The new `letOrVarKeyword` to replace the node's
  ///                   current `letOrVarKeyword`, if present.
  public func withLetOrVarKeyword(
    _ newChild: TokenSyntax?) -> ValueBindingPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missingToken(.letKeyword)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.letOrVarKeyword)
    return ValueBindingPatternSyntax(root: root, data: newData)
  }
  public var valuePattern: PatternSyntax {
    let child = data.cachedChild(at: Cursor.valuePattern)
    return makeSyntax(root: _root, data: child!) as! PatternSyntax
  }

  /// Returns a copy of the receiver with its `valuePattern` replaced.
  /// - param newChild: The new `valuePattern` to replace the node's
  ///                   current `valuePattern`, if present.
  public func withValuePattern(
    _ newChild: PatternSyntax?) -> ValueBindingPatternSyntax {
    let raw = newChild?.raw ?? RawSyntax.missing(.pattern)
    let (root, newData) = data.replacingChild(raw,
                                              at: Cursor.valuePattern)
    return ValueBindingPatternSyntax(root: root, data: newData)
  }

  /// Determines if two `ValueBindingPatternSyntax` nodes are equal to each other.
  public static func ==(lhs: ValueBindingPatternSyntax, rhs: ValueBindingPatternSyntax) -> Bool {
    return lhs._data === rhs._data
  }

  /// A unique hash value for this node.
  public var hashValue: Int {
    return ObjectIdentifier(_data).hashValue
  }
}


public protocol DeclGroupSyntax: Syntax {
  var attributes: AttributeListSyntax? { get }
  func withAttributes(_ newChild: AttributeListSyntax?) -> Self
  var modifiers: ModifierListSyntax? { get }
  func withModifiers(_ newChild: ModifierListSyntax?) -> Self
  var members: MemberDeclBlockSyntax { get }
  func withMembers(_ newChild: MemberDeclBlockSyntax?) -> Self
}
public protocol BracedSyntax: Syntax {
  var leftBrace: TokenSyntax { get }
  func withLeftBrace(_ newChild: TokenSyntax?) -> Self
  var rightBrace: TokenSyntax { get }
  func withRightBrace(_ newChild: TokenSyntax?) -> Self
}
public protocol IdentifiedDeclSyntax: Syntax {
  var identifier: TokenSyntax { get }
  func withIdentifier(_ newChild: TokenSyntax?) -> Self
}
public protocol WithCodeBlockSyntax: Syntax {
  var body: CodeBlockSyntax { get }
  func withBody(_ newChild: CodeBlockSyntax?) -> Self
}
public protocol ParenthesizedSyntax: Syntax {
  var leftParen: TokenSyntax { get }
  func withLeftParen(_ newChild: TokenSyntax?) -> Self
  var rightParen: TokenSyntax { get }
  func withRightParen(_ newChild: TokenSyntax?) -> Self
}
public protocol WithTrailingCommaSyntax: Syntax {
  var trailingComma: TokenSyntax? { get }
  func withTrailingComma(_ newChild: TokenSyntax?) -> Self
}
public protocol LabeledSyntax: Syntax {
  var labelName: TokenSyntax? { get }
  func withLabelName(_ newChild: TokenSyntax?) -> Self
  var labelColon: TokenSyntax? { get }
  func withLabelColon(_ newChild: TokenSyntax?) -> Self
}
public protocol WithStatementsSyntax: Syntax {
  var statements: CodeBlockItemListSyntax { get }
  func withStatements(_ newChild: CodeBlockItemListSyntax?) -> Self
}

extension CodeBlockSyntax: BracedSyntax, WithStatementsSyntax {}
extension DeclNameArgumentsSyntax: ParenthesizedSyntax {}
extension TupleExprSyntax: ParenthesizedSyntax {}
extension FunctionCallArgumentSyntax: WithTrailingCommaSyntax {}
extension TupleElementSyntax: WithTrailingCommaSyntax {}
extension ArrayElementSyntax: WithTrailingCommaSyntax {}
extension DictionaryElementSyntax: WithTrailingCommaSyntax {}
extension ClosureCaptureItemSyntax: WithTrailingCommaSyntax {}
extension ClosureParamSyntax: WithTrailingCommaSyntax {}
extension ClosureExprSyntax: BracedSyntax, WithStatementsSyntax {}
extension ExpressionSegmentSyntax: ParenthesizedSyntax {}
extension ObjcKeyPathExprSyntax: ParenthesizedSyntax {}
extension ObjcSelectorExprSyntax: ParenthesizedSyntax {}
extension ObjectLiteralExprSyntax: ParenthesizedSyntax {}
extension TypealiasDeclSyntax: IdentifiedDeclSyntax {}
extension AssociatedtypeDeclSyntax: IdentifiedDeclSyntax {}
extension ParameterClauseSyntax: ParenthesizedSyntax {}
extension PoundErrorDeclSyntax: ParenthesizedSyntax {}
extension PoundWarningDeclSyntax: ParenthesizedSyntax {}
extension InheritedTypeSyntax: WithTrailingCommaSyntax {}
extension ClassDeclSyntax: DeclGroupSyntax, IdentifiedDeclSyntax {}
extension StructDeclSyntax: DeclGroupSyntax, IdentifiedDeclSyntax {}
extension ProtocolDeclSyntax: DeclGroupSyntax, IdentifiedDeclSyntax {}
extension ExtensionDeclSyntax: DeclGroupSyntax {}
extension MemberDeclBlockSyntax: BracedSyntax {}
extension SourceFileSyntax: WithStatementsSyntax {}
extension FunctionParameterSyntax: WithTrailingCommaSyntax {}
extension FunctionDeclSyntax: IdentifiedDeclSyntax {}
extension AccessorParameterSyntax: ParenthesizedSyntax {}
extension AccessorBlockSyntax: BracedSyntax {}
extension PatternBindingSyntax: WithTrailingCommaSyntax {}
extension EnumCaseElementSyntax: WithTrailingCommaSyntax {}
extension EnumDeclSyntax: IdentifiedDeclSyntax {}
extension OperatorDeclSyntax: IdentifiedDeclSyntax {}
extension PrecedenceGroupDeclSyntax: IdentifiedDeclSyntax {}
extension WhileStmtSyntax: WithCodeBlockSyntax, LabeledSyntax {}
extension DeferStmtSyntax: WithCodeBlockSyntax {}
extension RepeatWhileStmtSyntax: WithCodeBlockSyntax, LabeledSyntax {}
extension GuardStmtSyntax: WithCodeBlockSyntax {}
extension ForInStmtSyntax: WithCodeBlockSyntax, LabeledSyntax {}
extension SwitchStmtSyntax: BracedSyntax, LabeledSyntax {}
extension DoStmtSyntax: WithCodeBlockSyntax, LabeledSyntax {}
extension ConditionElementSyntax: WithTrailingCommaSyntax {}
extension IfStmtSyntax: WithCodeBlockSyntax, LabeledSyntax {}
extension ElseBlockSyntax: WithCodeBlockSyntax {}
extension SwitchCaseSyntax: WithStatementsSyntax {}
extension CaseItemSyntax: WithTrailingCommaSyntax {}
extension SameTypeRequirementSyntax: WithTrailingCommaSyntax {}
extension GenericParameterSyntax: WithTrailingCommaSyntax {}
extension ConformanceRequirementSyntax: WithTrailingCommaSyntax {}
extension TupleTypeElementSyntax: WithTrailingCommaSyntax {}
extension TupleTypeSyntax: ParenthesizedSyntax {}
extension FunctionTypeSyntax: ParenthesizedSyntax {}
extension GenericArgumentSyntax: WithTrailingCommaSyntax {}
extension TuplePatternSyntax: ParenthesizedSyntax {}
extension TuplePatternElementSyntax: WithTrailingCommaSyntax, LabeledSyntax {}

/// MARK: Convenience methods

extension StructDeclSyntax {
  /// Creates a new StructDeclSyntax with the provided name as its identifier.
  /// - param name: The new struct's name.
  /// - returns: A new StructDeclSyntax with the same fields as the receiver,
  ///            but with the provided identifier.
  func withIdentifier(_ name: String) -> StructDeclSyntax {
    let newToken = SyntaxFactory.makeIdentifier(name,
      leadingTrivia: identifier.leadingTrivia,
      trailingTrivia: identifier.trailingTrivia)
    return withIdentifier(newToken)
  }
}

open class SyntaxRewriter {
  open func visit(_ node: UnknownDeclSyntax) -> DeclSyntax 
  open func visit(_ node: UnknownExprSyntax) -> ExprSyntax 
  open func visit(_ node: UnknownStmtSyntax) -> StmtSyntax 
  open func visit(_ node: UnknownTypeSyntax) -> TypeSyntax 
  open func visit(_ node: UnknownPatternSyntax) -> PatternSyntax 
  open func visit(_ node: CodeBlockItemSyntax) -> Syntax 
  open func visit(_ node: CodeBlockItemListSyntax) -> Syntax 
  open func visit(_ node: CodeBlockSyntax) -> Syntax 
  open func visit(_ node: InOutExprSyntax) -> ExprSyntax 
  open func visit(_ node: PoundColumnExprSyntax) -> ExprSyntax 
  open func visit(_ node: FunctionCallArgumentListSyntax) -> Syntax 
  open func visit(_ node: TupleElementListSyntax) -> Syntax 
  open func visit(_ node: ArrayElementListSyntax) -> Syntax 
  open func visit(_ node: DictionaryElementListSyntax) -> Syntax 
  open func visit(_ node: StringInterpolationSegmentsSyntax) -> Syntax 
  open func visit(_ node: TryExprSyntax) -> ExprSyntax 
  open func visit(_ node: DeclNameArgumentSyntax) -> Syntax 
  open func visit(_ node: DeclNameArgumentListSyntax) -> Syntax 
  open func visit(_ node: DeclNameArgumentsSyntax) -> Syntax 
  open func visit(_ node: IdentifierExprSyntax) -> ExprSyntax 
  open func visit(_ node: SuperRefExprSyntax) -> ExprSyntax 
  open func visit(_ node: NilLiteralExprSyntax) -> ExprSyntax 
  open func visit(_ node: DiscardAssignmentExprSyntax) -> ExprSyntax 
  open func visit(_ node: AssignmentExprSyntax) -> ExprSyntax 
  open func visit(_ node: SequenceExprSyntax) -> ExprSyntax 
  open func visit(_ node: ExprListSyntax) -> Syntax 
  open func visit(_ node: PoundLineExprSyntax) -> ExprSyntax 
  open func visit(_ node: PoundFileExprSyntax) -> ExprSyntax 
  open func visit(_ node: PoundFunctionExprSyntax) -> ExprSyntax 
  open func visit(_ node: PoundDsohandleExprSyntax) -> ExprSyntax 
  open func visit(_ node: SymbolicReferenceExprSyntax) -> ExprSyntax 
  open func visit(_ node: PrefixOperatorExprSyntax) -> ExprSyntax 
  open func visit(_ node: BinaryOperatorExprSyntax) -> ExprSyntax 
  open func visit(_ node: ArrowExprSyntax) -> ExprSyntax 
  open func visit(_ node: FloatLiteralExprSyntax) -> ExprSyntax 
  open func visit(_ node: TupleExprSyntax) -> ExprSyntax 
  open func visit(_ node: ArrayExprSyntax) -> ExprSyntax 
  open func visit(_ node: DictionaryExprSyntax) -> ExprSyntax 
  open func visit(_ node: ImplicitMemberExprSyntax) -> ExprSyntax 
  open func visit(_ node: FunctionCallArgumentSyntax) -> Syntax 
  open func visit(_ node: TupleElementSyntax) -> Syntax 
  open func visit(_ node: ArrayElementSyntax) -> Syntax 
  open func visit(_ node: DictionaryElementSyntax) -> Syntax 
  open func visit(_ node: IntegerLiteralExprSyntax) -> ExprSyntax 
  open func visit(_ node: StringLiteralExprSyntax) -> ExprSyntax 
  open func visit(_ node: BooleanLiteralExprSyntax) -> ExprSyntax 
  open func visit(_ node: TernaryExprSyntax) -> ExprSyntax 
  open func visit(_ node: MemberAccessExprSyntax) -> ExprSyntax 
  open func visit(_ node: DotSelfExprSyntax) -> ExprSyntax 
  open func visit(_ node: IsExprSyntax) -> ExprSyntax 
  open func visit(_ node: AsExprSyntax) -> ExprSyntax 
  open func visit(_ node: TypeExprSyntax) -> ExprSyntax 
  open func visit(_ node: ClosureCaptureItemSyntax) -> Syntax 
  open func visit(_ node: ClosureCaptureItemListSyntax) -> Syntax 
  open func visit(_ node: ClosureCaptureSignatureSyntax) -> Syntax 
  open func visit(_ node: ClosureParamSyntax) -> Syntax 
  open func visit(_ node: ClosureParamListSyntax) -> Syntax 
  open func visit(_ node: ClosureSignatureSyntax) -> Syntax 
  open func visit(_ node: ClosureExprSyntax) -> ExprSyntax 
  open func visit(_ node: UnresolvedPatternExprSyntax) -> ExprSyntax 
  open func visit(_ node: FunctionCallExprSyntax) -> ExprSyntax 
  open func visit(_ node: SubscriptExprSyntax) -> ExprSyntax 
  open func visit(_ node: OptionalChainingExprSyntax) -> ExprSyntax 
  open func visit(_ node: ForcedValueExprSyntax) -> ExprSyntax 
  open func visit(_ node: PostfixUnaryExprSyntax) -> ExprSyntax 
  open func visit(_ node: SpecializeExprSyntax) -> ExprSyntax 
  open func visit(_ node: StringSegmentSyntax) -> Syntax 
  open func visit(_ node: ExpressionSegmentSyntax) -> Syntax 
  open func visit(_ node: StringInterpolationExprSyntax) -> ExprSyntax 
  open func visit(_ node: KeyPathExprSyntax) -> ExprSyntax 
  open func visit(_ node: ObjcNamePieceSyntax) -> Syntax 
  open func visit(_ node: ObjcNameSyntax) -> Syntax 
  open func visit(_ node: ObjcKeyPathExprSyntax) -> ExprSyntax 
  open func visit(_ node: ObjcSelectorExprSyntax) -> ExprSyntax 
  open func visit(_ node: EditorPlaceholderExprSyntax) -> ExprSyntax 
  open func visit(_ node: ObjectLiteralExprSyntax) -> ExprSyntax 
  open func visit(_ node: TypeInitializerClauseSyntax) -> Syntax 
  open func visit(_ node: TypealiasDeclSyntax) -> DeclSyntax 
  open func visit(_ node: AssociatedtypeDeclSyntax) -> DeclSyntax 
  open func visit(_ node: FunctionParameterListSyntax) -> Syntax 
  open func visit(_ node: ParameterClauseSyntax) -> Syntax 
  open func visit(_ node: ReturnClauseSyntax) -> Syntax 
  open func visit(_ node: FunctionSignatureSyntax) -> Syntax 
  open func visit(_ node: IfConfigClauseSyntax) -> Syntax 
  open func visit(_ node: IfConfigClauseListSyntax) -> Syntax 
  open func visit(_ node: IfConfigDeclSyntax) -> DeclSyntax 
  open func visit(_ node: PoundErrorDeclSyntax) -> DeclSyntax 
  open func visit(_ node: PoundWarningDeclSyntax) -> DeclSyntax 
  open func visit(_ node: DeclModifierSyntax) -> Syntax 
  open func visit(_ node: InheritedTypeSyntax) -> Syntax 
  open func visit(_ node: InheritedTypeListSyntax) -> Syntax 
  open func visit(_ node: TypeInheritanceClauseSyntax) -> Syntax 
  open func visit(_ node: ClassDeclSyntax) -> DeclSyntax 
  open func visit(_ node: StructDeclSyntax) -> DeclSyntax 
  open func visit(_ node: ProtocolDeclSyntax) -> DeclSyntax 
  open func visit(_ node: ExtensionDeclSyntax) -> DeclSyntax 
  open func visit(_ node: MemberDeclBlockSyntax) -> Syntax 
  open func visit(_ node: DeclListSyntax) -> Syntax 
  open func visit(_ node: SourceFileSyntax) -> Syntax 
  open func visit(_ node: InitializerClauseSyntax) -> Syntax 
  open func visit(_ node: FunctionParameterSyntax) -> Syntax 
  open func visit(_ node: ModifierListSyntax) -> Syntax 
  open func visit(_ node: FunctionDeclSyntax) -> DeclSyntax 
  open func visit(_ node: InitializerDeclSyntax) -> DeclSyntax 
  open func visit(_ node: DeinitializerDeclSyntax) -> DeclSyntax 
  open func visit(_ node: SubscriptDeclSyntax) -> DeclSyntax 
  open func visit(_ node: AccessLevelModifierSyntax) -> Syntax 
  open func visit(_ node: AccessPathComponentSyntax) -> Syntax 
  open func visit(_ node: AccessPathSyntax) -> Syntax 
  open func visit(_ node: ImportDeclSyntax) -> DeclSyntax 
  open func visit(_ node: AccessorParameterSyntax) -> Syntax 
  open func visit(_ node: AccessorDeclSyntax) -> DeclSyntax 
  open func visit(_ node: AccessorListSyntax) -> Syntax 
  open func visit(_ node: AccessorBlockSyntax) -> Syntax 
  open func visit(_ node: PatternBindingSyntax) -> Syntax 
  open func visit(_ node: PatternBindingListSyntax) -> Syntax 
  open func visit(_ node: VariableDeclSyntax) -> DeclSyntax 
  open func visit(_ node: EnumCaseElementSyntax) -> Syntax 
  open func visit(_ node: EnumCaseElementListSyntax) -> Syntax 
  open func visit(_ node: EnumCaseDeclSyntax) -> DeclSyntax 
  open func visit(_ node: EnumDeclSyntax) -> DeclSyntax 
  open func visit(_ node: OperatorDeclSyntax) -> DeclSyntax 
  open func visit(_ node: InfixOperatorGroupSyntax) -> Syntax 
  open func visit(_ node: PrecedenceGroupDeclSyntax) -> DeclSyntax 
  open func visit(_ node: PrecedenceGroupAttributeListSyntax) -> Syntax 
  open func visit(_ node: PrecedenceGroupRelationSyntax) -> Syntax 
  open func visit(_ node: PrecedenceGroupNameListSyntax) -> Syntax 
  open func visit(_ node: PrecedenceGroupNameElementSyntax) -> Syntax 
  open func visit(_ node: PrecedenceGroupAssignmentSyntax) -> Syntax 
  open func visit(_ node: PrecedenceGroupAssociativitySyntax) -> Syntax 
  open func visit(_ node: TokenListSyntax) -> Syntax 
  open func visit(_ node: AttributeSyntax) -> Syntax 
  open func visit(_ node: AttributeListSyntax) -> Syntax 
  open func visit(_ node: ContinueStmtSyntax) -> StmtSyntax 
  open func visit(_ node: WhileStmtSyntax) -> StmtSyntax 
  open func visit(_ node: DeferStmtSyntax) -> StmtSyntax 
  open func visit(_ node: ExpressionStmtSyntax) -> StmtSyntax 
  open func visit(_ node: SwitchCaseListSyntax) -> Syntax 
  open func visit(_ node: RepeatWhileStmtSyntax) -> StmtSyntax 
  open func visit(_ node: GuardStmtSyntax) -> StmtSyntax 
  open func visit(_ node: WhereClauseSyntax) -> Syntax 
  open func visit(_ node: ForInStmtSyntax) -> StmtSyntax 
  open func visit(_ node: SwitchStmtSyntax) -> StmtSyntax 
  open func visit(_ node: CatchClauseListSyntax) -> Syntax 
  open func visit(_ node: DoStmtSyntax) -> StmtSyntax 
  open func visit(_ node: ReturnStmtSyntax) -> StmtSyntax 
  open func visit(_ node: FallthroughStmtSyntax) -> StmtSyntax 
  open func visit(_ node: BreakStmtSyntax) -> StmtSyntax 
  open func visit(_ node: CaseItemListSyntax) -> Syntax 
  open func visit(_ node: ConditionElementSyntax) -> Syntax 
  open func visit(_ node: AvailabilityConditionSyntax) -> Syntax 
  open func visit(_ node: MatchingPatternConditionSyntax) -> Syntax 
  open func visit(_ node: OptionalBindingConditionSyntax) -> Syntax 
  open func visit(_ node: ConditionElementListSyntax) -> Syntax 
  open func visit(_ node: DeclarationStmtSyntax) -> StmtSyntax 
  open func visit(_ node: ThrowStmtSyntax) -> StmtSyntax 
  open func visit(_ node: IfStmtSyntax) -> StmtSyntax 
  open func visit(_ node: ElseIfContinuationSyntax) -> Syntax 
  open func visit(_ node: ElseBlockSyntax) -> Syntax 
  open func visit(_ node: SwitchCaseSyntax) -> Syntax 
  open func visit(_ node: SwitchDefaultLabelSyntax) -> Syntax 
  open func visit(_ node: CaseItemSyntax) -> Syntax 
  open func visit(_ node: SwitchCaseLabelSyntax) -> Syntax 
  open func visit(_ node: CatchClauseSyntax) -> Syntax 
  open func visit(_ node: GenericWhereClauseSyntax) -> Syntax 
  open func visit(_ node: GenericRequirementListSyntax) -> Syntax 
  open func visit(_ node: SameTypeRequirementSyntax) -> Syntax 
  open func visit(_ node: GenericParameterListSyntax) -> Syntax 
  open func visit(_ node: GenericParameterSyntax) -> Syntax 
  open func visit(_ node: GenericParameterClauseSyntax) -> Syntax 
  open func visit(_ node: ConformanceRequirementSyntax) -> Syntax 
  open func visit(_ node: SimpleTypeIdentifierSyntax) -> TypeSyntax 
  open func visit(_ node: MemberTypeIdentifierSyntax) -> TypeSyntax 
  open func visit(_ node: ArrayTypeSyntax) -> TypeSyntax 
  open func visit(_ node: DictionaryTypeSyntax) -> TypeSyntax 
  open func visit(_ node: MetatypeTypeSyntax) -> TypeSyntax 
  open func visit(_ node: OptionalTypeSyntax) -> TypeSyntax 
  open func visit(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) -> TypeSyntax 
  open func visit(_ node: CompositionTypeElementSyntax) -> Syntax 
  open func visit(_ node: CompositionTypeElementListSyntax) -> Syntax 
  open func visit(_ node: CompositionTypeSyntax) -> TypeSyntax 
  open func visit(_ node: TupleTypeElementSyntax) -> Syntax 
  open func visit(_ node: TupleTypeElementListSyntax) -> Syntax 
  open func visit(_ node: TupleTypeSyntax) -> TypeSyntax 
  open func visit(_ node: FunctionTypeSyntax) -> TypeSyntax 
  open func visit(_ node: AttributedTypeSyntax) -> TypeSyntax 
  open func visit(_ node: GenericArgumentListSyntax) -> Syntax 
  open func visit(_ node: GenericArgumentSyntax) -> Syntax 
  open func visit(_ node: GenericArgumentClauseSyntax) -> Syntax 
  open func visit(_ node: TypeAnnotationSyntax) -> Syntax 
  open func visit(_ node: EnumCasePatternSyntax) -> PatternSyntax 
  open func visit(_ node: IsTypePatternSyntax) -> PatternSyntax 
  open func visit(_ node: OptionalPatternSyntax) -> PatternSyntax 
  open func visit(_ node: IdentifierPatternSyntax) -> PatternSyntax 
  open func visit(_ node: AsTypePatternSyntax) -> PatternSyntax 
  open func visit(_ node: TuplePatternSyntax) -> PatternSyntax 
  open func visit(_ node: WildcardPatternSyntax) -> PatternSyntax 
  open func visit(_ node: TuplePatternElementSyntax) -> Syntax 
  open func visit(_ node: ExpressionPatternSyntax) -> PatternSyntax 
  open func visit(_ node: TuplePatternElementListSyntax) -> Syntax 
  open func visit(_ node: ValueBindingPatternSyntax) -> PatternSyntax 
  open func visit(_ token: TokenSyntax) -> Syntax 
}