tsc-ts 0.0.4 → 0.0.5

package/src/compiler/printer/factory-base.ts

@@ -0,0 +1,2577 @@
+// Generated by scripts/generate-visitor.mjs; do not edit.
+import {
+  ArrayLiteralExpression,
+  ArrayTypeNode,
+  ArrowFunction,
+  AsExpression,
+  AwaitExpression,
+  BinaryExpression,
+  BindingElement,
+  BindingPattern,
+  Block,
+  BreakStatement,
+  CallExpression,
+  CallSignatureDeclaration,
+  CaseBlock,
+  CaseOrDefaultClause,
+  CatchClause,
+  ClassDeclaration,
+  ClassExpression,
+  ClassStaticBlockDeclaration,
+  ComputedPropertyName,
+  ConditionalExpression,
+  ConditionalTypeNode,
+  ConstructSignatureDeclaration,
+  ConstructorDeclaration,
+  ConstructorTypeNode,
+  ContinueStatement,
+  Decorator,
+  DeleteExpression,
+  DoStatement,
+  ElementAccessExpression,
+  EnumDeclaration,
+  EnumMember,
+  ExportAssignment,
+  ExportDeclaration,
+  ExportSpecifier,
+  ExpressionStatement,
+  ExpressionWithTypeArguments,
+  ExternalModuleReference,
+  ForInOrOfStatement,
+  ForStatement,
+  FunctionDeclaration,
+  FunctionExpression,
+  FunctionTypeNode,
+  GetAccessorDeclaration,
+  HeritageClause,
+  IfStatement,
+  ImportAttribute,
+  ImportAttributes,
+  ImportClause,
+  ImportDeclaration,
+  ImportEqualsDeclaration,
+  ImportSpecifier,
+  ImportTypeNode,
+  IndexSignatureDeclaration,
+  IndexedAccessTypeNode,
+  InferTypeNode,
+  InterfaceDeclaration,
+  IntersectionTypeNode,
+  JSDoc,
+  JSDocAugmentsTag,
+  JSDocCallbackTag,
+  JSDocDeprecatedTag,
+  JSDocImplementsTag,
+  JSDocImportTag,
+  JSDocLink,
+  JSDocLinkCode,
+  JSDocLinkPlain,
+  JSDocNameReference,
+  JSDocNonNullableType,
+  JSDocNullableType,
+  JSDocOptionalType,
+  JSDocOverloadTag,
+  JSDocOverrideTag,
+  JSDocParameterOrPropertyTag,
+  JSDocPrivateTag,
+  JSDocProtectedTag,
+  JSDocPublicTag,
+  JSDocReadonlyTag,
+  JSDocReturnTag,
+  JSDocSatisfiesTag,
+  JSDocSeeTag,
+  JSDocSignature,
+  JSDocTemplateTag,
+  JSDocThisTag,
+  JSDocThrowsTag,
+  JSDocTypeExpression,
+  JSDocTypeLiteral,
+  JSDocTypeTag,
+  JSDocTypedefTag,
+  JSDocUnknownTag,
+  JSDocVariadicType,
+  JsxAttribute,
+  JsxAttributes,
+  JsxClosingElement,
+  JsxElement,
+  JsxExpression,
+  JsxFragment,
+  JsxNamespacedName,
+  JsxOpeningElement,
+  JsxSelfClosingElement,
+  JsxSpreadAttribute,
+  LabeledStatement,
+  LiteralTypeNode,
+  MappedTypeNode,
+  MetaProperty,
+  MethodDeclaration,
+  MethodSignatureDeclaration,
+  MissingDeclaration,
+  ModuleBlock,
+  ModuleDeclaration,
+  NamedExports,
+  NamedImports,
+  NamedTupleMember,
+  NamespaceExport,
+  NamespaceExportDeclaration,
+  NamespaceImport,
+  NewExpression,
+  NonNullExpression,
+  ObjectLiteralExpression,
+  OptionalTypeNode,
+  ParameterDeclaration,
+  ParenthesizedExpression,
+  ParenthesizedTypeNode,
+  PartiallyEmittedExpression,
+  PostfixUnaryExpression,
+  PrefixUnaryExpression,
+  PropertyAccessExpression,
+  PropertyAssignment,
+  PropertyDeclaration,
+  PropertySignatureDeclaration,
+  QualifiedName,
+  RestTypeNode,
+  ReturnStatement,
+  SatisfiesExpression,
+  SetAccessorDeclaration,
+  ShorthandPropertyAssignment,
+  SpreadAssignment,
+  SpreadElement,
+  SwitchStatement,
+  SyntaxList,
+  SyntheticReferenceExpression,
+  TaggedTemplateExpression,
+  TemplateExpression,
+  TemplateLiteralTypeNode,
+  TemplateLiteralTypeSpan,
+  TemplateSpan,
+  ThrowStatement,
+  TryStatement,
+  TupleTypeNode,
+  TypeAliasDeclaration,
+  TypeAssertion,
+  TypeLiteralNode,
+  TypeOfExpression,
+  TypeOperatorNode,
+  TypeParameterDeclaration,
+  TypePredicateNode,
+  TypeQueryNode,
+  TypeReferenceNode,
+  UnionTypeNode,
+  VariableDeclaration,
+  VariableDeclarationList,
+  VariableStatement,
+  VoidExpression,
+  WhileStatement,
+  WithStatement,
+  YieldExpression,
+  type BindingName,
+  type ConciseBody,
+  type EntityName,
+  type Expression,
+  type ForInitializer,
+  type FunctionBody,
+  type Identifier,
+  type ImportAttributeName,
+  type JSDocFullName,
+  type JsxAttributeName,
+  type JsxAttributeValue,
+  type JsxClosingFragment,
+  type JsxOpeningFragment,
+  type JsxTagNameExpression,
+  type LeftHandSideExpression,
+  type MemberName,
+  type ModuleBody,
+  type ModuleExportName,
+  type ModuleName,
+  type ModuleReference,
+  type NamedExportBindings,
+  type NamedImportBindings,
+  type NodeFlags,
+  type PropertyName,
+  type Statement,
+  type TemplateHead,
+  type TemplateLiteral,
+  type TemplateMiddleOrTail,
+  type TypeNode,
+  type TypePredicateParameterName,
+  type ModifierList,
+  type Node,
+  type NodeList,
+  type Token,
+} from '../ast.js';
+import type { SyntaxKind } from '../syntax-kind.js';
+
+/** `update*` functions: return the node if no child changed, else a copy with the node's flags, range and original. */
+export abstract class NodeFactoryBase {
+  protected abstract finishUpdate(updated: Node, original: Node): boolean;
+
+  updateArrayLiteralExpression(
+    node: ArrayLiteralExpression,
+    elements: NodeList,
+    multiLine: boolean,
+  ): ArrayLiteralExpression {
+    if (elements !== node.elements || multiLine !== node.multiLine) {
+      const updated = new ArrayLiteralExpression(elements, multiLine);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode {
+    if (elementType !== node.elementType) {
+      const updated = new ArrayTypeNode(elementType);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateArrowFunction(
+    node: ArrowFunction,
+    modifiers: ModifierList | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    equalsGreaterThanToken: Token | undefined,
+    body: ConciseBody,
+  ): ArrowFunction {
+    if (
+      modifiers !== node.modifiers ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      equalsGreaterThanToken !== node.equalsGreaterThanToken ||
+      body !== node.body
+    ) {
+      const updated = new ArrowFunction(
+        modifiers,
+        typeParameters,
+        parameters,
+        typeNode,
+        fullSignature,
+        equalsGreaterThanToken,
+        body,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateAsExpression(node: AsExpression, expression: Expression, typeNode: TypeNode): AsExpression {
+    if (expression !== node.expression || typeNode !== node.type) {
+      const updated = new AsExpression(expression, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression {
+    if (expression !== node.expression) {
+      const updated = new AwaitExpression(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateBinaryExpression(
+    node: BinaryExpression,
+    modifiers: ModifierList | undefined,
+    left: Expression,
+    typeNode: TypeNode | undefined,
+    operatorToken: Token,
+    right: Expression,
+  ): BinaryExpression {
+    if (
+      modifiers !== node.modifiers ||
+      left !== node.left ||
+      typeNode !== node.type ||
+      operatorToken !== node.operatorToken ||
+      right !== node.right
+    ) {
+      const updated = new BinaryExpression(modifiers, left, typeNode, operatorToken, right);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateBindingElement(
+    node: BindingElement,
+    dotDotDotToken: Token | undefined,
+    propertyName: PropertyName | undefined,
+    name: BindingName | undefined,
+    initializer: Expression | undefined,
+  ): BindingElement {
+    if (
+      dotDotDotToken !== node.dotDotDotToken ||
+      propertyName !== node.propertyName ||
+      name !== node.name ||
+      initializer !== node.initializer
+    ) {
+      const updated = new BindingElement(dotDotDotToken, propertyName, name, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateBindingPattern(node: BindingPattern, elements: NodeList): BindingPattern {
+    if (elements !== node.elements) {
+      const updated = new BindingPattern(node.kind, elements);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateBlock(node: Block, statements: NodeList, multiLine: boolean): Block {
+    if (statements !== node.statements || multiLine !== node.multiLine) {
+      const updated = new Block(statements, multiLine);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement {
+    if (label !== node.label) {
+      const updated = new BreakStatement(label);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateCallExpression(
+    node: CallExpression,
+    expression: Expression,
+    questionDotToken: Token | undefined,
+    typeArguments: NodeList | undefined,
+    args: NodeList,
+    flags: NodeFlags,
+  ): CallExpression {
+    if (
+      expression !== node.expression ||
+      questionDotToken !== node.questionDotToken ||
+      typeArguments !== node.typeArguments ||
+      args !== node.arguments ||
+      flags !== node.flags
+    ) {
+      const updated = new CallExpression(expression, questionDotToken, typeArguments, args, flags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateCallSignatureDeclaration(
+    node: CallSignatureDeclaration,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): CallSignatureDeclaration {
+    if (typeParameters !== node.typeParameters || parameters !== node.parameters || typeNode !== node.type) {
+      const updated = new CallSignatureDeclaration(typeParameters, parameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateCaseBlock(node: CaseBlock, clauses: NodeList): CaseBlock {
+    if (clauses !== node.clauses) {
+      const updated = new CaseBlock(clauses);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateCaseOrDefaultClause(
+    node: CaseOrDefaultClause,
+    expression: Expression | undefined,
+    statements: NodeList,
+  ): CaseOrDefaultClause {
+    if (expression !== node.expression || statements !== node.statements) {
+      const updated = new CaseOrDefaultClause(node.kind, expression, statements);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateCatchClause(
+    node: CatchClause,
+    variableDeclaration: VariableDeclaration | undefined,
+    block: Block,
+  ): CatchClause {
+    if (variableDeclaration !== node.variableDeclaration || block !== node.block) {
+      const updated = new CatchClause(variableDeclaration, block);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateClassDeclaration(
+    node: ClassDeclaration,
+    modifiers: ModifierList | undefined,
+    name: Identifier | undefined,
+    typeParameters: NodeList | undefined,
+    heritageClauses: NodeList | undefined,
+    members: NodeList,
+  ): ClassDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      heritageClauses !== node.heritageClauses ||
+      members !== node.members
+    ) {
+      const updated = new ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateClassExpression(
+    node: ClassExpression,
+    modifiers: ModifierList | undefined,
+    name: Identifier | undefined,
+    typeParameters: NodeList | undefined,
+    heritageClauses: NodeList | undefined,
+    members: NodeList,
+  ): ClassExpression {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      heritageClauses !== node.heritageClauses ||
+      members !== node.members
+    ) {
+      const updated = new ClassExpression(modifiers, name, typeParameters, heritageClauses, members);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateClassStaticBlockDeclaration(
+    node: ClassStaticBlockDeclaration,
+    modifiers: ModifierList | undefined,
+    body: Block,
+  ): ClassStaticBlockDeclaration {
+    if (modifiers !== node.modifiers || body !== node.body) {
+      const updated = new ClassStaticBlockDeclaration(modifiers, body);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName {
+    if (expression !== node.expression) {
+      const updated = new ComputedPropertyName(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateConditionalExpression(
+    node: ConditionalExpression,
+    condition: Expression,
+    questionToken: Token,
+    whenTrue: Expression,
+    colonToken: Token,
+    whenFalse: Expression,
+  ): ConditionalExpression {
+    if (
+      condition !== node.condition ||
+      questionToken !== node.questionToken ||
+      whenTrue !== node.whenTrue ||
+      colonToken !== node.colonToken ||
+      whenFalse !== node.whenFalse
+    ) {
+      const updated = new ConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateConditionalTypeNode(
+    node: ConditionalTypeNode,
+    checkType: TypeNode,
+    extendsType: TypeNode,
+    trueType: TypeNode,
+    falseType: TypeNode,
+  ): ConditionalTypeNode {
+    if (
+      checkType !== node.checkType ||
+      extendsType !== node.extendsType ||
+      trueType !== node.trueType ||
+      falseType !== node.falseType
+    ) {
+      const updated = new ConditionalTypeNode(checkType, extendsType, trueType, falseType);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateConstructorDeclaration(
+    node: ConstructorDeclaration,
+    modifiers: ModifierList | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    body: FunctionBody | undefined,
+  ): ConstructorDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      body !== node.body
+    ) {
+      const updated = new ConstructorDeclaration(modifiers, typeParameters, parameters, typeNode, fullSignature, body);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateConstructorTypeNode(
+    node: ConstructorTypeNode,
+    modifiers: ModifierList | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): ConstructorTypeNode {
+    if (
+      modifiers !== node.modifiers ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type
+    ) {
+      const updated = new ConstructorTypeNode(modifiers, typeParameters, parameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateConstructSignatureDeclaration(
+    node: ConstructSignatureDeclaration,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): ConstructSignatureDeclaration {
+    if (typeParameters !== node.typeParameters || parameters !== node.parameters || typeNode !== node.type) {
+      const updated = new ConstructSignatureDeclaration(typeParameters, parameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement {
+    if (label !== node.label) {
+      const updated = new ContinueStatement(label);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateDecorator(node: Decorator, expression: LeftHandSideExpression): Decorator {
+    if (expression !== node.expression) {
+      const updated = new Decorator(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression {
+    if (expression !== node.expression) {
+      const updated = new DeleteExpression(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement {
+    if (statement !== node.statement || expression !== node.expression) {
+      const updated = new DoStatement(statement, expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateElementAccessExpression(
+    node: ElementAccessExpression,
+    expression: Expression,
+    questionDotToken: Token | undefined,
+    argumentExpression: Expression,
+    flags: NodeFlags,
+  ): ElementAccessExpression {
+    if (
+      expression !== node.expression ||
+      questionDotToken !== node.questionDotToken ||
+      argumentExpression !== node.argumentExpression ||
+      flags !== node.flags
+    ) {
+      const updated = new ElementAccessExpression(expression, questionDotToken, argumentExpression, flags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateEnumDeclaration(
+    node: EnumDeclaration,
+    modifiers: ModifierList | undefined,
+    name: Identifier,
+    members: NodeList,
+  ): EnumDeclaration {
+    if (modifiers !== node.modifiers || name !== node.name || members !== node.members) {
+      const updated = new EnumDeclaration(modifiers, name, members);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression | undefined): EnumMember {
+    if (name !== node.name || initializer !== node.initializer) {
+      const updated = new EnumMember(name, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateExportAssignment(
+    node: ExportAssignment,
+    modifiers: ModifierList | undefined,
+    isExportEquals: boolean,
+    typeNode: TypeNode | undefined,
+    expression: Expression,
+  ): ExportAssignment {
+    if (
+      modifiers !== node.modifiers ||
+      isExportEquals !== node.isExportEquals ||
+      typeNode !== node.type ||
+      expression !== node.expression
+    ) {
+      const updated = new ExportAssignment(modifiers, isExportEquals, typeNode, expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateExportDeclaration(
+    node: ExportDeclaration,
+    modifiers: ModifierList | undefined,
+    isTypeOnly: boolean,
+    exportClause: NamedExportBindings | undefined,
+    moduleSpecifier: Expression | undefined,
+    attributes: ImportAttributes | undefined,
+  ): ExportDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      isTypeOnly !== node.isTypeOnly ||
+      exportClause !== node.exportClause ||
+      moduleSpecifier !== node.moduleSpecifier ||
+      attributes !== node.attributes
+    ) {
+      const updated = new ExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, attributes);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateExportSpecifier(
+    node: ExportSpecifier,
+    isTypeOnly: boolean,
+    propertyName: ModuleExportName | undefined,
+    name: ModuleExportName,
+  ): ExportSpecifier {
+    if (isTypeOnly !== node.isTypeOnly || propertyName !== node.propertyName || name !== node.name) {
+      const updated = new ExportSpecifier(isTypeOnly, propertyName, name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement {
+    if (expression !== node.expression) {
+      const updated = new ExpressionStatement(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateExpressionWithTypeArguments(
+    node: ExpressionWithTypeArguments,
+    expression: Expression,
+    typeArguments: NodeList | undefined,
+  ): ExpressionWithTypeArguments {
+    if (expression !== node.expression || typeArguments !== node.typeArguments) {
+      const updated = new ExpressionWithTypeArguments(expression, typeArguments);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateExternalModuleReference(node: ExternalModuleReference, expression: Expression): ExternalModuleReference {
+    if (expression !== node.expression) {
+      const updated = new ExternalModuleReference(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateForInOrOfStatement(
+    node: ForInOrOfStatement,
+    awaitModifier: Token | undefined,
+    initializer: ForInitializer,
+    expression: Expression,
+    statement: Statement,
+  ): ForInOrOfStatement {
+    if (
+      awaitModifier !== node.awaitModifier ||
+      initializer !== node.initializer ||
+      expression !== node.expression ||
+      statement !== node.statement
+    ) {
+      const updated = new ForInOrOfStatement(node.kind, awaitModifier, initializer, expression, statement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateForStatement(
+    node: ForStatement,
+    initializer: ForInitializer | undefined,
+    condition: Expression | undefined,
+    incrementor: Expression | undefined,
+    statement: Statement,
+  ): ForStatement {
+    if (
+      initializer !== node.initializer ||
+      condition !== node.condition ||
+      incrementor !== node.incrementor ||
+      statement !== node.statement
+    ) {
+      const updated = new ForStatement(initializer, condition, incrementor, statement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateFunctionDeclaration(
+    node: FunctionDeclaration,
+    modifiers: ModifierList | undefined,
+    asteriskToken: Token | undefined,
+    name: Identifier | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    body: FunctionBody | undefined,
+  ): FunctionDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      asteriskToken !== node.asteriskToken ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      body !== node.body
+    ) {
+      const updated = new FunctionDeclaration(
+        modifiers,
+        asteriskToken,
+        name,
+        typeParameters,
+        parameters,
+        typeNode,
+        fullSignature,
+        body,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateFunctionExpression(
+    node: FunctionExpression,
+    modifiers: ModifierList | undefined,
+    asteriskToken: Token | undefined,
+    name: Identifier | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    body: FunctionBody,
+  ): FunctionExpression {
+    if (
+      modifiers !== node.modifiers ||
+      asteriskToken !== node.asteriskToken ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      body !== node.body
+    ) {
+      const updated = new FunctionExpression(
+        modifiers,
+        asteriskToken,
+        name,
+        typeParameters,
+        parameters,
+        typeNode,
+        fullSignature,
+        body,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateFunctionTypeNode(
+    node: FunctionTypeNode,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): FunctionTypeNode {
+    if (typeParameters !== node.typeParameters || parameters !== node.parameters || typeNode !== node.type) {
+      const updated = new FunctionTypeNode(typeParameters, parameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateGetAccessorDeclaration(
+    node: GetAccessorDeclaration,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    body: FunctionBody | undefined,
+  ): GetAccessorDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      body !== node.body
+    ) {
+      const updated = new GetAccessorDeclaration(
+        modifiers,
+        name,
+        typeParameters,
+        parameters,
+        typeNode,
+        fullSignature,
+        body,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateHeritageClause(node: HeritageClause, token: SyntaxKind, types: NodeList): HeritageClause {
+    if (token !== node.token || types !== node.types) {
+      const updated = new HeritageClause(token, types);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateIfStatement(
+    node: IfStatement,
+    expression: Expression,
+    thenStatement: Statement,
+    elseStatement: Statement | undefined,
+  ): IfStatement {
+    if (
+      expression !== node.expression ||
+      thenStatement !== node.thenStatement ||
+      elseStatement !== node.elseStatement
+    ) {
+      const updated = new IfStatement(expression, thenStatement, elseStatement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportAttribute(
+    node: ImportAttribute,
+    name: ImportAttributeName | undefined,
+    value: Expression,
+  ): ImportAttribute {
+    if (name !== node.name || value !== node.value) {
+      const updated = new ImportAttribute(name, value);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportAttributes(
+    node: ImportAttributes,
+    token: SyntaxKind,
+    attributes: NodeList,
+    multiLine: boolean,
+  ): ImportAttributes {
+    if (token !== node.token || attributes !== node.attributes || multiLine !== node.multiLine) {
+      const updated = new ImportAttributes(token, attributes, multiLine);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportClause(
+    node: ImportClause,
+    phaseModifier: SyntaxKind | undefined,
+    name: Identifier | undefined,
+    namedBindings: NamedImportBindings | undefined,
+  ): ImportClause {
+    if (phaseModifier !== node.phaseModifier || name !== node.name || namedBindings !== node.namedBindings) {
+      const updated = new ImportClause(phaseModifier, name, namedBindings);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportDeclaration(
+    node: ImportDeclaration,
+    modifiers: ModifierList | undefined,
+    importClause: ImportClause | undefined,
+    moduleSpecifier: Expression,
+    attributes: ImportAttributes | undefined,
+  ): ImportDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      importClause !== node.importClause ||
+      moduleSpecifier !== node.moduleSpecifier ||
+      attributes !== node.attributes
+    ) {
+      const updated = new ImportDeclaration(node.kind, modifiers, importClause, moduleSpecifier, attributes);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportEqualsDeclaration(
+    node: ImportEqualsDeclaration,
+    modifiers: ModifierList | undefined,
+    isTypeOnly: boolean,
+    name: Identifier,
+    moduleReference: ModuleReference,
+  ): ImportEqualsDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      isTypeOnly !== node.isTypeOnly ||
+      name !== node.name ||
+      moduleReference !== node.moduleReference
+    ) {
+      const updated = new ImportEqualsDeclaration(modifiers, isTypeOnly, name, moduleReference);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportSpecifier(
+    node: ImportSpecifier,
+    isTypeOnly: boolean,
+    propertyName: ModuleExportName | undefined,
+    name: Identifier,
+  ): ImportSpecifier {
+    if (isTypeOnly !== node.isTypeOnly || propertyName !== node.propertyName || name !== node.name) {
+      const updated = new ImportSpecifier(isTypeOnly, propertyName, name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateImportTypeNode(
+    node: ImportTypeNode,
+    isTypeOf: boolean,
+    argument: TypeNode,
+    attributes: ImportAttributes | undefined,
+    qualifier: EntityName | undefined,
+    typeArguments: NodeList | undefined,
+  ): ImportTypeNode {
+    if (
+      isTypeOf !== node.isTypeOf ||
+      argument !== node.argument ||
+      attributes !== node.attributes ||
+      qualifier !== node.qualifier ||
+      typeArguments !== node.typeArguments
+    ) {
+      const updated = new ImportTypeNode(isTypeOf, argument, attributes, qualifier, typeArguments);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateIndexedAccessTypeNode(
+    node: IndexedAccessTypeNode,
+    objectType: TypeNode,
+    indexType: TypeNode,
+  ): IndexedAccessTypeNode {
+    if (objectType !== node.objectType || indexType !== node.indexType) {
+      const updated = new IndexedAccessTypeNode(objectType, indexType);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateIndexSignatureDeclaration(
+    node: IndexSignatureDeclaration,
+    modifiers: ModifierList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): IndexSignatureDeclaration {
+    if (modifiers !== node.modifiers || parameters !== node.parameters || typeNode !== node.type) {
+      const updated = new IndexSignatureDeclaration(modifiers, parameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration): InferTypeNode {
+    if (typeParameter !== node.typeParameter) {
+      const updated = new InferTypeNode(typeParameter);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateInterfaceDeclaration(
+    node: InterfaceDeclaration,
+    modifiers: ModifierList | undefined,
+    name: Identifier,
+    typeParameters: NodeList | undefined,
+    heritageClauses: NodeList | undefined,
+    members: NodeList,
+  ): InterfaceDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      heritageClauses !== node.heritageClauses ||
+      members !== node.members
+    ) {
+      const updated = new InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeList): IntersectionTypeNode {
+    if (types !== node.types) {
+      const updated = new IntersectionTypeNode(types);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDoc(node: JSDoc, comment: NodeList, tags: NodeList | undefined): JSDoc {
+    if (comment !== node.comment || tags !== node.tags) {
+      const updated = new JSDoc(comment, tags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocAugmentsTag(
+    node: JSDocAugmentsTag,
+    tagName: Identifier,
+    className: ExpressionWithTypeArguments,
+    comment: NodeList | undefined,
+  ): JSDocAugmentsTag {
+    if (tagName !== node.tagName || className !== node.className || comment !== node.comment) {
+      const updated = new JSDocAugmentsTag(tagName, className, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocCallbackTag(
+    node: JSDocCallbackTag,
+    tagName: Identifier,
+    typeExpression: TypeNode,
+    name: JSDocFullName | undefined,
+    comment: NodeList | undefined,
+  ): JSDocCallbackTag {
+    if (
+      tagName !== node.tagName ||
+      typeExpression !== node.typeExpression ||
+      name !== node.name ||
+      comment !== node.comment
+    ) {
+      const updated = new JSDocCallbackTag(tagName, typeExpression, name, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocDeprecatedTag(
+    node: JSDocDeprecatedTag,
+    tagName: Identifier,
+    comment: NodeList | undefined,
+  ): JSDocDeprecatedTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocDeprecatedTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocImplementsTag(
+    node: JSDocImplementsTag,
+    tagName: Identifier,
+    className: ExpressionWithTypeArguments,
+    comment: NodeList | undefined,
+  ): JSDocImplementsTag {
+    if (tagName !== node.tagName || className !== node.className || comment !== node.comment) {
+      const updated = new JSDocImplementsTag(tagName, className, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocImportTag(
+    node: JSDocImportTag,
+    tagName: Identifier,
+    importClause: ImportClause | undefined,
+    moduleSpecifier: Expression,
+    attributes: ImportAttributes | undefined,
+    comment: NodeList | undefined,
+  ): JSDocImportTag {
+    if (
+      tagName !== node.tagName ||
+      importClause !== node.importClause ||
+      moduleSpecifier !== node.moduleSpecifier ||
+      attributes !== node.attributes ||
+      comment !== node.comment
+    ) {
+      const updated = new JSDocImportTag(tagName, importClause, moduleSpecifier, attributes, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocLink(node: JSDocLink, name: EntityName | undefined, text: string): JSDocLink {
+    if (name !== node.name || text !== node.text) {
+      const updated = new JSDocLink(name, text);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocLinkCode(node: JSDocLinkCode, name: EntityName | undefined, text: string): JSDocLinkCode {
+    if (name !== node.name || text !== node.text) {
+      const updated = new JSDocLinkCode(name, text);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocLinkPlain(node: JSDocLinkPlain, name: EntityName | undefined, text: string): JSDocLinkPlain {
+    if (name !== node.name || text !== node.text) {
+      const updated = new JSDocLinkPlain(name, text);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocNameReference(node: JSDocNameReference, name: EntityName | undefined): JSDocNameReference {
+    if (name !== node.name) {
+      const updated = new JSDocNameReference(name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocNonNullableType(node: JSDocNonNullableType, typeNode: TypeNode): JSDocNonNullableType {
+    if (typeNode !== node.type) {
+      const updated = new JSDocNonNullableType(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocNullableType(node: JSDocNullableType, typeNode: TypeNode): JSDocNullableType {
+    if (typeNode !== node.type) {
+      const updated = new JSDocNullableType(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocOptionalType(node: JSDocOptionalType, typeNode: TypeNode): JSDocOptionalType {
+    if (typeNode !== node.type) {
+      const updated = new JSDocOptionalType(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocOverloadTag(
+    node: JSDocOverloadTag,
+    tagName: Identifier,
+    typeExpression: TypeNode,
+    comment: NodeList | undefined,
+  ): JSDocOverloadTag {
+    if (tagName !== node.tagName || typeExpression !== node.typeExpression || comment !== node.comment) {
+      const updated = new JSDocOverloadTag(tagName, typeExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier, comment: NodeList | undefined): JSDocOverrideTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocOverrideTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocParameterOrPropertyTag(
+    node: JSDocParameterOrPropertyTag,
+    tagName: Identifier,
+    name: EntityName,
+    isBracketed: boolean,
+    typeExpression: TypeNode | undefined,
+    isNameFirst: boolean,
+    comment: NodeList | undefined,
+  ): JSDocParameterOrPropertyTag {
+    if (
+      tagName !== node.tagName ||
+      name !== node.name ||
+      isBracketed !== node.isBracketed ||
+      typeExpression !== node.typeExpression ||
+      isNameFirst !== node.isNameFirst ||
+      comment !== node.comment
+    ) {
+      const updated = new JSDocParameterOrPropertyTag(
+        node.kind,
+        tagName,
+        name,
+        isBracketed,
+        typeExpression,
+        isNameFirst,
+        comment,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocPrivateTag(node: JSDocPrivateTag, tagName: Identifier, comment: NodeList | undefined): JSDocPrivateTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocPrivateTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocProtectedTag(
+    node: JSDocProtectedTag,
+    tagName: Identifier,
+    comment: NodeList | undefined,
+  ): JSDocProtectedTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocProtectedTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocPublicTag(node: JSDocPublicTag, tagName: Identifier, comment: NodeList | undefined): JSDocPublicTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocPublicTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocReadonlyTag(node: JSDocReadonlyTag, tagName: Identifier, comment: NodeList | undefined): JSDocReadonlyTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocReadonlyTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocReturnTag(
+    node: JSDocReturnTag,
+    tagName: Identifier,
+    typeExpression: TypeNode | undefined,
+    comment: NodeList | undefined,
+  ): JSDocReturnTag {
+    if (tagName !== node.tagName || typeExpression !== node.typeExpression || comment !== node.comment) {
+      const updated = new JSDocReturnTag(tagName, typeExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocSatisfiesTag(
+    node: JSDocSatisfiesTag,
+    tagName: Identifier,
+    typeExpression: TypeNode,
+    comment: NodeList | undefined,
+  ): JSDocSatisfiesTag {
+    if (tagName !== node.tagName || typeExpression !== node.typeExpression || comment !== node.comment) {
+      const updated = new JSDocSatisfiesTag(tagName, typeExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocSeeTag(
+    node: JSDocSeeTag,
+    tagName: Identifier,
+    nameExpression: TypeNode | undefined,
+    comment: NodeList | undefined,
+  ): JSDocSeeTag {
+    if (tagName !== node.tagName || nameExpression !== node.nameExpression || comment !== node.comment) {
+      const updated = new JSDocSeeTag(tagName, nameExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocSignature(
+    node: JSDocSignature,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): JSDocSignature {
+    if (typeParameters !== node.typeParameters || parameters !== node.parameters || typeNode !== node.type) {
+      const updated = new JSDocSignature(typeParameters, parameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocTemplateTag(
+    node: JSDocTemplateTag,
+    tagName: Identifier,
+    constraint: Node | undefined,
+    typeParameters: NodeList,
+    comment: NodeList | undefined,
+  ): JSDocTemplateTag {
+    if (
+      tagName !== node.tagName ||
+      constraint !== node.constraint ||
+      typeParameters !== node.typeParameters ||
+      comment !== node.comment
+    ) {
+      const updated = new JSDocTemplateTag(tagName, constraint, typeParameters, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocThisTag(
+    node: JSDocThisTag,
+    tagName: Identifier,
+    typeExpression: TypeNode,
+    comment: NodeList | undefined,
+  ): JSDocThisTag {
+    if (tagName !== node.tagName || typeExpression !== node.typeExpression || comment !== node.comment) {
+      const updated = new JSDocThisTag(tagName, typeExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocThrowsTag(
+    node: JSDocThrowsTag,
+    tagName: Identifier,
+    typeExpression: TypeNode | undefined,
+    comment: NodeList | undefined,
+  ): JSDocThrowsTag {
+    if (tagName !== node.tagName || typeExpression !== node.typeExpression || comment !== node.comment) {
+      const updated = new JSDocThrowsTag(tagName, typeExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocTypedefTag(
+    node: JSDocTypedefTag,
+    tagName: Identifier,
+    typeExpression: Node | undefined,
+    name: JSDocFullName | undefined,
+    comment: NodeList | undefined,
+  ): JSDocTypedefTag {
+    if (
+      tagName !== node.tagName ||
+      typeExpression !== node.typeExpression ||
+      name !== node.name ||
+      comment !== node.comment
+    ) {
+      const updated = new JSDocTypedefTag(tagName, typeExpression, name, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocTypeExpression(node: JSDocTypeExpression, typeNode: TypeNode): JSDocTypeExpression {
+    if (typeNode !== node.type) {
+      const updated = new JSDocTypeExpression(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocTypeLiteral(
+    node: JSDocTypeLiteral,
+    jsdocPropertyTags: Node[] | undefined,
+    isArrayType: boolean,
+  ): JSDocTypeLiteral {
+    if (jsdocPropertyTags !== node.jsdocPropertyTags || isArrayType !== node.isArrayType) {
+      const updated = new JSDocTypeLiteral(jsdocPropertyTags, isArrayType);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocTypeTag(
+    node: JSDocTypeTag,
+    tagName: Identifier,
+    typeExpression: Node,
+    comment: NodeList | undefined,
+  ): JSDocTypeTag {
+    if (tagName !== node.tagName || typeExpression !== node.typeExpression || comment !== node.comment) {
+      const updated = new JSDocTypeTag(tagName, typeExpression, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: NodeList | undefined): JSDocUnknownTag {
+    if (tagName !== node.tagName || comment !== node.comment) {
+      const updated = new JSDocUnknownTag(tagName, comment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJSDocVariadicType(node: JSDocVariadicType, typeNode: TypeNode): JSDocVariadicType {
+    if (typeNode !== node.type) {
+      const updated = new JSDocVariadicType(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxAttribute(
+    node: JsxAttribute,
+    name: JsxAttributeName,
+    initializer: JsxAttributeValue | undefined,
+  ): JsxAttribute {
+    if (name !== node.name || initializer !== node.initializer) {
+      const updated = new JsxAttribute(name, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxAttributes(node: JsxAttributes, properties: NodeList): JsxAttributes {
+    if (properties !== node.properties) {
+      const updated = new JsxAttributes(properties);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxClosingElement(node: JsxClosingElement, tagName: JsxTagNameExpression): JsxClosingElement {
+    if (tagName !== node.tagName) {
+      const updated = new JsxClosingElement(tagName);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxElement(
+    node: JsxElement,
+    openingElement: JsxOpeningElement,
+    children: NodeList,
+    closingElement: JsxClosingElement,
+  ): JsxElement {
+    if (
+      openingElement !== node.openingElement ||
+      children !== node.children ||
+      closingElement !== node.closingElement
+    ) {
+      const updated = new JsxElement(openingElement, children, closingElement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxExpression(
+    node: JsxExpression,
+    dotDotDotToken: Token | undefined,
+    expression: Expression | undefined,
+  ): JsxExpression {
+    if (dotDotDotToken !== node.dotDotDotToken || expression !== node.expression) {
+      const updated = new JsxExpression(dotDotDotToken, expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxFragment(
+    node: JsxFragment,
+    openingFragment: JsxOpeningFragment,
+    children: NodeList,
+    closingFragment: JsxClosingFragment,
+  ): JsxFragment {
+    if (
+      openingFragment !== node.openingFragment ||
+      children !== node.children ||
+      closingFragment !== node.closingFragment
+    ) {
+      const updated = new JsxFragment(openingFragment, children, closingFragment);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxNamespacedName(node: JsxNamespacedName, namespace: Identifier, name: Identifier): JsxNamespacedName {
+    if (namespace !== node.namespace || name !== node.name) {
+      const updated = new JsxNamespacedName(namespace, name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxOpeningElement(
+    node: JsxOpeningElement,
+    tagName: JsxTagNameExpression,
+    typeArguments: NodeList | undefined,
+    attributes: JsxAttributes,
+  ): JsxOpeningElement {
+    if (tagName !== node.tagName || typeArguments !== node.typeArguments || attributes !== node.attributes) {
+      const updated = new JsxOpeningElement(tagName, typeArguments, attributes);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxSelfClosingElement(
+    node: JsxSelfClosingElement,
+    tagName: JsxTagNameExpression,
+    typeArguments: NodeList | undefined,
+    attributes: JsxAttributes,
+  ): JsxSelfClosingElement {
+    if (tagName !== node.tagName || typeArguments !== node.typeArguments || attributes !== node.attributes) {
+      const updated = new JsxSelfClosingElement(tagName, typeArguments, attributes);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateJsxSpreadAttribute(node: JsxSpreadAttribute, expression: Expression): JsxSpreadAttribute {
+    if (expression !== node.expression) {
+      const updated = new JsxSpreadAttribute(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement {
+    if (label !== node.label || statement !== node.statement) {
+      const updated = new LabeledStatement(label, statement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateLiteralTypeNode(node: LiteralTypeNode, literal: Node): LiteralTypeNode {
+    if (literal !== node.literal) {
+      const updated = new LiteralTypeNode(literal);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateMappedTypeNode(
+    node: MappedTypeNode,
+    readonlyToken: Token | undefined,
+    typeParameter: TypeParameterDeclaration,
+    nameType: TypeNode | undefined,
+    questionToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    members: NodeList | undefined,
+  ): MappedTypeNode {
+    if (
+      readonlyToken !== node.readonlyToken ||
+      typeParameter !== node.typeParameter ||
+      nameType !== node.nameType ||
+      questionToken !== node.questionToken ||
+      typeNode !== node.type ||
+      members !== node.members
+    ) {
+      const updated = new MappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, typeNode, members);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateMetaProperty(node: MetaProperty, keywordToken: SyntaxKind, name: Identifier): MetaProperty {
+    if (keywordToken !== node.keywordToken || name !== node.name) {
+      const updated = new MetaProperty(keywordToken, name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateMethodDeclaration(
+    node: MethodDeclaration,
+    modifiers: ModifierList | undefined,
+    asteriskToken: Token | undefined,
+    name: PropertyName,
+    postfixToken: Token | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    body: FunctionBody | undefined,
+  ): MethodDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      asteriskToken !== node.asteriskToken ||
+      name !== node.name ||
+      postfixToken !== node.postfixToken ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      body !== node.body
+    ) {
+      const updated = new MethodDeclaration(
+        modifiers,
+        asteriskToken,
+        name,
+        postfixToken,
+        typeParameters,
+        parameters,
+        typeNode,
+        fullSignature,
+        body,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateMethodSignatureDeclaration(
+    node: MethodSignatureDeclaration,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    postfixToken: Token | undefined,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+  ): MethodSignatureDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      postfixToken !== node.postfixToken ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type
+    ) {
+      const updated = new MethodSignatureDeclaration(
+        modifiers,
+        name,
+        postfixToken,
+        typeParameters,
+        parameters,
+        typeNode,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateMissingDeclaration(node: MissingDeclaration, modifiers: ModifierList | undefined): MissingDeclaration {
+    if (modifiers !== node.modifiers) {
+      const updated = new MissingDeclaration(modifiers);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateModuleBlock(node: ModuleBlock, statements: NodeList): ModuleBlock {
+    if (statements !== node.statements) {
+      const updated = new ModuleBlock(statements);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateModuleDeclaration(
+    node: ModuleDeclaration,
+    modifiers: ModifierList | undefined,
+    keyword: SyntaxKind,
+    name: ModuleName,
+    body: ModuleBody | undefined,
+  ): ModuleDeclaration {
+    if (modifiers !== node.modifiers || keyword !== node.keyword || name !== node.name || body !== node.body) {
+      const updated = new ModuleDeclaration(modifiers, keyword, name, body);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNamedExports(node: NamedExports, elements: NodeList): NamedExports {
+    if (elements !== node.elements) {
+      const updated = new NamedExports(elements);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNamedImports(node: NamedImports, elements: NodeList): NamedImports {
+    if (elements !== node.elements) {
+      const updated = new NamedImports(elements);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNamedTupleMember(
+    node: NamedTupleMember,
+    dotDotDotToken: Token | undefined,
+    name: Identifier,
+    questionToken: Token | undefined,
+    typeNode: TypeNode,
+  ): NamedTupleMember {
+    if (
+      dotDotDotToken !== node.dotDotDotToken ||
+      name !== node.name ||
+      questionToken !== node.questionToken ||
+      typeNode !== node.type
+    ) {
+      const updated = new NamedTupleMember(dotDotDotToken, name, questionToken, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNamespaceExport(node: NamespaceExport, name: ModuleExportName): NamespaceExport {
+    if (name !== node.name) {
+      const updated = new NamespaceExport(name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNamespaceExportDeclaration(
+    node: NamespaceExportDeclaration,
+    modifiers: ModifierList | undefined,
+    name: Identifier,
+  ): NamespaceExportDeclaration {
+    if (modifiers !== node.modifiers || name !== node.name) {
+      const updated = new NamespaceExportDeclaration(modifiers, name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport {
+    if (name !== node.name) {
+      const updated = new NamespaceImport(name);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNewExpression(
+    node: NewExpression,
+    expression: Expression,
+    typeArguments: NodeList | undefined,
+    args: NodeList | undefined,
+  ): NewExpression {
+    if (expression !== node.expression || typeArguments !== node.typeArguments || args !== node.arguments) {
+      const updated = new NewExpression(expression, typeArguments, args);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateNonNullExpression(node: NonNullExpression, expression: Expression, flags: NodeFlags): NonNullExpression {
+    if (expression !== node.expression || flags !== node.flags) {
+      const updated = new NonNullExpression(expression, flags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateObjectLiteralExpression(
+    node: ObjectLiteralExpression,
+    properties: NodeList,
+    multiLine: boolean,
+  ): ObjectLiteralExpression {
+    if (properties !== node.properties || multiLine !== node.multiLine) {
+      const updated = new ObjectLiteralExpression(properties, multiLine);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateOptionalTypeNode(node: OptionalTypeNode, typeNode: TypeNode): OptionalTypeNode {
+    if (typeNode !== node.type) {
+      const updated = new OptionalTypeNode(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateParameterDeclaration(
+    node: ParameterDeclaration,
+    modifiers: ModifierList | undefined,
+    dotDotDotToken: Token | undefined,
+    name: BindingName,
+    questionToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    initializer: Expression | undefined,
+  ): ParameterDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      dotDotDotToken !== node.dotDotDotToken ||
+      name !== node.name ||
+      questionToken !== node.questionToken ||
+      typeNode !== node.type ||
+      initializer !== node.initializer
+    ) {
+      const updated = new ParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, typeNode, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression {
+    if (expression !== node.expression) {
+      const updated = new ParenthesizedExpression(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateParenthesizedTypeNode(node: ParenthesizedTypeNode, typeNode: TypeNode): ParenthesizedTypeNode {
+    if (typeNode !== node.type) {
+      const updated = new ParenthesizedTypeNode(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePartiallyEmittedExpression(
+    node: PartiallyEmittedExpression,
+    expression: Expression,
+  ): PartiallyEmittedExpression {
+    if (expression !== node.expression) {
+      const updated = new PartiallyEmittedExpression(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePostfixUnaryExpression(
+    node: PostfixUnaryExpression,
+    operand: Expression,
+    operator: SyntaxKind,
+  ): PostfixUnaryExpression {
+    if (operand !== node.operand || operator !== node.operator) {
+      const updated = new PostfixUnaryExpression(operand, operator);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePrefixUnaryExpression(
+    node: PrefixUnaryExpression,
+    operator: SyntaxKind,
+    operand: Expression,
+  ): PrefixUnaryExpression {
+    if (operator !== node.operator || operand !== node.operand) {
+      const updated = new PrefixUnaryExpression(operator, operand);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePropertyAccessExpression(
+    node: PropertyAccessExpression,
+    expression: Expression,
+    questionDotToken: Token | undefined,
+    name: MemberName,
+    flags: NodeFlags,
+  ): PropertyAccessExpression {
+    if (
+      expression !== node.expression ||
+      questionDotToken !== node.questionDotToken ||
+      name !== node.name ||
+      flags !== node.flags
+    ) {
+      const updated = new PropertyAccessExpression(expression, questionDotToken, name, flags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePropertyAssignment(
+    node: PropertyAssignment,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    postfixToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    initializer: Expression,
+  ): PropertyAssignment {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      postfixToken !== node.postfixToken ||
+      typeNode !== node.type ||
+      initializer !== node.initializer
+    ) {
+      const updated = new PropertyAssignment(modifiers, name, postfixToken, typeNode, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePropertyDeclaration(
+    node: PropertyDeclaration,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    postfixToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    initializer: Expression | undefined,
+  ): PropertyDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      postfixToken !== node.postfixToken ||
+      typeNode !== node.type ||
+      initializer !== node.initializer
+    ) {
+      const updated = new PropertyDeclaration(modifiers, name, postfixToken, typeNode, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updatePropertySignatureDeclaration(
+    node: PropertySignatureDeclaration,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    postfixToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    initializer: Expression | undefined,
+  ): PropertySignatureDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      postfixToken !== node.postfixToken ||
+      typeNode !== node.type ||
+      initializer !== node.initializer
+    ) {
+      const updated = new PropertySignatureDeclaration(modifiers, name, postfixToken, typeNode, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName {
+    if (left !== node.left || right !== node.right) {
+      const updated = new QualifiedName(left, right);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateRestTypeNode(node: RestTypeNode, typeNode: TypeNode): RestTypeNode {
+    if (typeNode !== node.type) {
+      const updated = new RestTypeNode(typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement {
+    if (expression !== node.expression) {
+      const updated = new ReturnStatement(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSatisfiesExpression(
+    node: SatisfiesExpression,
+    expression: Expression,
+    typeNode: TypeNode,
+  ): SatisfiesExpression {
+    if (expression !== node.expression || typeNode !== node.type) {
+      const updated = new SatisfiesExpression(expression, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSetAccessorDeclaration(
+    node: SetAccessorDeclaration,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    typeParameters: NodeList | undefined,
+    parameters: NodeList,
+    typeNode: TypeNode | undefined,
+    fullSignature: TypeNode | undefined,
+    body: FunctionBody | undefined,
+  ): SetAccessorDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      parameters !== node.parameters ||
+      typeNode !== node.type ||
+      fullSignature !== node.fullSignature ||
+      body !== node.body
+    ) {
+      const updated = new SetAccessorDeclaration(
+        modifiers,
+        name,
+        typeParameters,
+        parameters,
+        typeNode,
+        fullSignature,
+        body,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateShorthandPropertyAssignment(
+    node: ShorthandPropertyAssignment,
+    modifiers: ModifierList | undefined,
+    name: PropertyName,
+    postfixToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    equalsToken: Token | undefined,
+    objectAssignmentInitializer: Expression | undefined,
+  ): ShorthandPropertyAssignment {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      postfixToken !== node.postfixToken ||
+      typeNode !== node.type ||
+      equalsToken !== node.equalsToken ||
+      objectAssignmentInitializer !== node.objectAssignmentInitializer
+    ) {
+      const updated = new ShorthandPropertyAssignment(
+        modifiers,
+        name,
+        postfixToken,
+        typeNode,
+        equalsToken,
+        objectAssignmentInitializer,
+      );
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment {
+    if (expression !== node.expression) {
+      const updated = new SpreadAssignment(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement {
+    if (expression !== node.expression) {
+      const updated = new SpreadElement(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement {
+    if (expression !== node.expression || caseBlock !== node.caseBlock) {
+      const updated = new SwitchStatement(expression, caseBlock);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSyntaxList(node: SyntaxList, children: Node[]): SyntaxList {
+    if (children !== node.children) {
+      const updated = new SyntaxList(children);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateSyntheticReferenceExpression(
+    node: SyntheticReferenceExpression,
+    expression: Expression,
+    thisArg: Expression,
+  ): SyntheticReferenceExpression {
+    if (expression !== node.expression || thisArg !== node.thisArg) {
+      const updated = new SyntheticReferenceExpression(expression, thisArg);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTaggedTemplateExpression(
+    node: TaggedTemplateExpression,
+    tag: Expression,
+    questionDotToken: Token | undefined,
+    typeArguments: NodeList | undefined,
+    template: TemplateLiteral,
+    flags: NodeFlags,
+  ): TaggedTemplateExpression {
+    if (
+      tag !== node.tag ||
+      questionDotToken !== node.questionDotToken ||
+      typeArguments !== node.typeArguments ||
+      template !== node.template ||
+      flags !== node.flags
+    ) {
+      const updated = new TaggedTemplateExpression(tag, questionDotToken, typeArguments, template, flags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: NodeList): TemplateExpression {
+    if (head !== node.head || templateSpans !== node.templateSpans) {
+      const updated = new TemplateExpression(head, templateSpans);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTemplateLiteralTypeNode(
+    node: TemplateLiteralTypeNode,
+    head: TemplateHead,
+    templateSpans: NodeList,
+  ): TemplateLiteralTypeNode {
+    if (head !== node.head || templateSpans !== node.templateSpans) {
+      const updated = new TemplateLiteralTypeNode(head, templateSpans);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTemplateLiteralTypeSpan(
+    node: TemplateLiteralTypeSpan,
+    typeNode: TypeNode,
+    literal: TemplateMiddleOrTail,
+  ): TemplateLiteralTypeSpan {
+    if (typeNode !== node.type || literal !== node.literal) {
+      const updated = new TemplateLiteralTypeSpan(typeNode, literal);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddleOrTail): TemplateSpan {
+    if (expression !== node.expression || literal !== node.literal) {
+      const updated = new TemplateSpan(expression, literal);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement {
+    if (expression !== node.expression) {
+      const updated = new ThrowStatement(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTryStatement(
+    node: TryStatement,
+    tryBlock: Block,
+    catchClause: CatchClause | undefined,
+    finallyBlock: Block | undefined,
+  ): TryStatement {
+    if (tryBlock !== node.tryBlock || catchClause !== node.catchClause || finallyBlock !== node.finallyBlock) {
+      const updated = new TryStatement(tryBlock, catchClause, finallyBlock);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTupleTypeNode(node: TupleTypeNode, elements: NodeList): TupleTypeNode {
+    if (elements !== node.elements) {
+      const updated = new TupleTypeNode(elements);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeAliasDeclaration(
+    node: TypeAliasDeclaration,
+    modifiers: ModifierList | undefined,
+    name: Identifier,
+    typeParameters: NodeList | undefined,
+    typeNode: TypeNode,
+  ): TypeAliasDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      typeParameters !== node.typeParameters ||
+      typeNode !== node.type
+    ) {
+      const updated = new TypeAliasDeclaration(node.kind, modifiers, name, typeParameters, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeAssertion(node: TypeAssertion, typeNode: TypeNode, expression: Expression): TypeAssertion {
+    if (typeNode !== node.type || expression !== node.expression) {
+      const updated = new TypeAssertion(typeNode, expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeLiteralNode(node: TypeLiteralNode, members: NodeList): TypeLiteralNode {
+    if (members !== node.members) {
+      const updated = new TypeLiteralNode(members);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression {
+    if (expression !== node.expression) {
+      const updated = new TypeOfExpression(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeOperatorNode(node: TypeOperatorNode, operator: SyntaxKind, typeNode: TypeNode): TypeOperatorNode {
+    if (operator !== node.operator || typeNode !== node.type) {
+      const updated = new TypeOperatorNode(operator, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeParameterDeclaration(
+    node: TypeParameterDeclaration,
+    modifiers: ModifierList | undefined,
+    name: Identifier,
+    constraint: TypeNode | undefined,
+    expression: Expression | undefined,
+    defaultType: TypeNode | undefined,
+  ): TypeParameterDeclaration {
+    if (
+      modifiers !== node.modifiers ||
+      name !== node.name ||
+      constraint !== node.constraint ||
+      expression !== node.expression ||
+      defaultType !== node.defaultType
+    ) {
+      const updated = new TypeParameterDeclaration(modifiers, name, constraint, expression, defaultType);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypePredicateNode(
+    node: TypePredicateNode,
+    assertsModifier: Token | undefined,
+    parameterName: TypePredicateParameterName,
+    typeNode: TypeNode | undefined,
+  ): TypePredicateNode {
+    if (assertsModifier !== node.assertsModifier || parameterName !== node.parameterName || typeNode !== node.type) {
+      const updated = new TypePredicateNode(assertsModifier, parameterName, typeNode);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName, typeArguments: NodeList | undefined): TypeQueryNode {
+    if (exprName !== node.exprName || typeArguments !== node.typeArguments) {
+      const updated = new TypeQueryNode(exprName, typeArguments);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateTypeReferenceNode(
+    node: TypeReferenceNode,
+    typeName: EntityName,
+    typeArguments: NodeList | undefined,
+  ): TypeReferenceNode {
+    if (typeName !== node.typeName || typeArguments !== node.typeArguments) {
+      const updated = new TypeReferenceNode(typeName, typeArguments);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateUnionTypeNode(node: UnionTypeNode, types: NodeList): UnionTypeNode {
+    if (types !== node.types) {
+      const updated = new UnionTypeNode(types);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateVariableDeclaration(
+    node: VariableDeclaration,
+    name: BindingName,
+    exclamationToken: Token | undefined,
+    typeNode: TypeNode | undefined,
+    initializer: Expression | undefined,
+  ): VariableDeclaration {
+    if (
+      name !== node.name ||
+      exclamationToken !== node.exclamationToken ||
+      typeNode !== node.type ||
+      initializer !== node.initializer
+    ) {
+      const updated = new VariableDeclaration(name, exclamationToken, typeNode, initializer);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateVariableDeclarationList(
+    node: VariableDeclarationList,
+    declarations: NodeList,
+    flags: NodeFlags,
+  ): VariableDeclarationList {
+    if (declarations !== node.declarations || flags !== node.flags) {
+      const updated = new VariableDeclarationList(declarations, flags);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateVariableStatement(
+    node: VariableStatement,
+    modifiers: ModifierList | undefined,
+    declarationList: VariableDeclarationList,
+  ): VariableStatement {
+    if (modifiers !== node.modifiers || declarationList !== node.declarationList) {
+      const updated = new VariableStatement(modifiers, declarationList);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression {
+    if (expression !== node.expression) {
+      const updated = new VoidExpression(expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement {
+    if (expression !== node.expression || statement !== node.statement) {
+      const updated = new WhileStatement(expression, statement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement {
+    if (expression !== node.expression || statement !== node.statement) {
+      const updated = new WithStatement(expression, statement);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+
+  updateYieldExpression(
+    node: YieldExpression,
+    asteriskToken: Token | undefined,
+    expression: Expression | undefined,
+  ): YieldExpression {
+    if (asteriskToken !== node.asteriskToken || expression !== node.expression) {
+      const updated = new YieldExpression(asteriskToken, expression);
+      this.finishUpdate(updated, node);
+      return updated;
+    }
+    return node;
+  }
+}