1namespace ts { 2 /** 3 * Visits a Node using the supplied visitor, possibly returning a new Node in its place. 4 * 5 * @param node The Node to visit. 6 * @param visitor The callback used to visit the Node. 7 * @param test A callback to execute to verify the Node is valid. 8 * @param lift An optional callback to execute to lift a NodeArray into a valid Node. 9 */ 10 export function visitNode<T extends Node>(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T; 11 12 /** 13 * Visits a Node using the supplied visitor, possibly returning a new Node in its place. 14 * 15 * @param node The Node to visit. 16 * @param visitor The callback used to visit the Node. 17 * @param test A callback to execute to verify the Node is valid. 18 * @param lift An optional callback to execute to lift a NodeArray into a valid Node. 19 */ 20 export function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined; 21 22 export function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined { 23 if (node === undefined || visitor === undefined) { 24 return node; 25 } 26 27 const visited = visitor(node); 28 if (visited === node) { 29 return node; 30 } 31 32 let visitedNode: Node | undefined; 33 if (visited === undefined) { 34 return undefined; 35 } 36 else if (isArray(visited)) { 37 visitedNode = (lift || extractSingleNode)(visited); 38 } 39 else { 40 visitedNode = visited; 41 } 42 43 Debug.assertNode(visitedNode, test); 44 return visitedNode as T; 45 } 46 47 /* @internal */ 48 export function visitNodes<T extends Node, U extends T>(nodes: NodeArray<T>, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): NodeArray<U>; 49 50 /** 51 * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. 52 * 53 * @param nodes The NodeArray to visit. 54 * @param visitor The callback used to visit a Node. 55 * @param test A node test to execute for each node. 56 * @param start An optional value indicating the starting offset at which to start visiting. 57 * @param count An optional value indicating the maximum number of nodes to visit. 58 */ 59 export function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>; 60 61 /* @internal */ 62 export function visitNodes<T extends Node, U extends T>(nodes: NodeArray<T> | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): NodeArray<U> | undefined; 63 64 /** 65 * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. 66 * 67 * @param nodes The NodeArray to visit. 68 * @param visitor The callback used to visit a Node. 69 * @param test A node test to execute for each node. 70 * @param start An optional value indicating the starting offset at which to start visiting. 71 * @param count An optional value indicating the maximum number of nodes to visit. 72 */ 73 export function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined; 74 75 /** 76 * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. 77 * 78 * @param nodes The NodeArray to visit. 79 * @param visitor The callback used to visit a Node. 80 * @param test A node test to execute for each node. 81 * @param start An optional value indicating the starting offset at which to start visiting. 82 * @param count An optional value indicating the maximum number of nodes to visit. 83 */ 84 export function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined { 85 if (nodes === undefined || visitor === undefined) { 86 return nodes; 87 } 88 89 // Ensure start and count have valid values 90 const length = nodes.length; 91 if (start === undefined || start < 0) { 92 start = 0; 93 } 94 95 if (count === undefined || count > length - start) { 96 count = length - start; 97 } 98 99 let hasTrailingComma: boolean | undefined; 100 let pos = -1; 101 let end = -1; 102 if (start > 0 || count < length) { 103 // Since this is a fragment of a node array, we do not copy over the previous location 104 // and will only copy over `hasTrailingComma` if we are including the last element. 105 hasTrailingComma = nodes.hasTrailingComma && start + count === length; 106 } 107 else { 108 pos = nodes.pos; 109 end = nodes.end; 110 hasTrailingComma = nodes.hasTrailingComma; 111 } 112 113 const updated = visitArrayWorker(nodes, visitor, test, start, count); 114 if (updated !== nodes as readonly T[]) { 115 // TODO(rbuckton): Remove dependency on `ts.factory` in favor of a provided factory. 116 const updatedArray = factory.createNodeArray(updated, hasTrailingComma); 117 setTextRangePosEnd(updatedArray, pos, end); 118 return updatedArray; 119 } 120 121 return nodes; 122 } 123 124 /* @internal */ 125 export function visitArray<T extends Node, U extends T>(nodes: T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): U[] | undefined; 126 /* @internal */ 127 export function visitArray<T extends Node, U extends T>(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number): readonly U[] | undefined; 128 /* @internal */ 129 export function visitArray<T extends Node>(nodes: T[] | undefined, visitor: Visitor, test: (node: Node) => node is T, start?: number, count?: number): T[] | undefined; 130 /* @internal */ 131 export function visitArray<T extends Node>(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is T, start?: number, count?: number): readonly T[] | undefined; 132 export function visitArray<T extends Node, U extends T>(nodes: readonly T[] | undefined, visitor: Visitor, test: (node: Node) => node is U, start?: number, count?: number) { 133 if (nodes === undefined) { 134 return nodes; 135 } 136 137 // Ensure start and count have valid values 138 const length = nodes.length; 139 if (start === undefined || start < 0) { 140 start = 0; 141 } 142 143 if (count === undefined || count > length - start) { 144 count = length - start; 145 } 146 147 return visitArrayWorker(nodes, visitor, test, start, count) as readonly U[]; 148 } 149 150 /* @internal */ 151 function visitArrayWorker<T extends Node>(nodes: readonly T[], visitor: Visitor, test: ((node: Node) => boolean) | undefined, start: number, count: number): readonly T[] | undefined { 152 let updated: T[] | undefined; 153 154 const length = nodes.length; 155 if (start > 0 || count < length) { 156 // If we are not visiting all of the original nodes, we must always create a new array. 157 updated = []; 158 } 159 160 // Visit each original node. 161 for (let i = 0; i < count; i++) { 162 const node: T = nodes[i + start]; 163 const visited = node !== undefined ? visitor(node) : undefined; 164 if (updated !== undefined || visited === undefined || visited !== node) { 165 if (updated === undefined) { 166 // Ensure we have a copy of `nodes`, up to the current index. 167 updated = nodes.slice(0, i); 168 } 169 if (visited) { 170 if (isArray(visited)) { 171 for (const visitedNode of visited) { 172 void Debug.assertNode(visitedNode, test); 173 updated.push(visitedNode as T); 174 } 175 } 176 else { 177 void Debug.assertNode(visited, test); 178 updated.push(visited as T); 179 } 180 } 181 } 182 } 183 184 return updated ?? nodes; 185 } 186 187 /** 188 * Starts a new lexical environment and visits a statement list, ending the lexical environment 189 * and merging hoisted declarations upon completion. 190 */ 191 export function visitLexicalEnvironment(statements: NodeArray<Statement>, visitor: Visitor, context: TransformationContext, start?: number, ensureUseStrict?: boolean, nodesVisitor: NodesVisitor = visitNodes) { 192 context.startLexicalEnvironment(); 193 statements = nodesVisitor(statements, visitor, isStatement, start); 194 if (ensureUseStrict) statements = context.factory.ensureUseStrict(statements); 195 return factory.mergeLexicalEnvironment(statements, context.endLexicalEnvironment()); 196 } 197 198 /** 199 * Starts a new lexical environment and visits a parameter list, suspending the lexical 200 * environment upon completion. 201 */ 202 export function visitParameterList(nodes: NodeArray<ParameterDeclaration>, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration>; 203 export function visitParameterList(nodes: NodeArray<ParameterDeclaration> | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration> | undefined; 204 export function visitParameterList(nodes: NodeArray<ParameterDeclaration> | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor = visitNodes) { 205 let updated: NodeArray<ParameterDeclaration> | undefined; 206 context.startLexicalEnvironment(); 207 if (nodes) { 208 context.setLexicalEnvironmentFlags(LexicalEnvironmentFlags.InParameters, true); 209 updated = nodesVisitor(nodes, visitor, isParameterDeclaration); 210 211 // As of ES2015, any runtime execution of that occurs in for a parameter (such as evaluating an 212 // initializer or a binding pattern), occurs in its own lexical scope. As a result, any expression 213 // that we might transform that introduces a temporary variable would fail as the temporary variable 214 // exists in a different lexical scope. To address this, we move any binding patterns and initializers 215 // in a parameter list to the body if we detect a variable being hoisted while visiting a parameter list 216 // when the emit target is greater than ES2015. 217 if (context.getLexicalEnvironmentFlags() & LexicalEnvironmentFlags.VariablesHoistedInParameters && 218 getEmitScriptTarget(context.getCompilerOptions()) >= ScriptTarget.ES2015) { 219 updated = addDefaultValueAssignmentsIfNeeded(updated, context); 220 } 221 context.setLexicalEnvironmentFlags(LexicalEnvironmentFlags.InParameters, false); 222 } 223 context.suspendLexicalEnvironment(); 224 return updated; 225 } 226 227 function addDefaultValueAssignmentsIfNeeded(parameters: NodeArray<ParameterDeclaration>, context: TransformationContext) { 228 let result: ParameterDeclaration[] | undefined; 229 for (let i = 0; i < parameters.length; i++) { 230 const parameter = parameters[i]; 231 const updated = addDefaultValueAssignmentIfNeeded(parameter, context); 232 if (result || updated !== parameter) { 233 if (!result) result = parameters.slice(0, i); 234 result[i] = updated; 235 } 236 } 237 if (result) { 238 return setTextRange(context.factory.createNodeArray(result, parameters.hasTrailingComma), parameters); 239 } 240 return parameters; 241 } 242 243 function addDefaultValueAssignmentIfNeeded(parameter: ParameterDeclaration, context: TransformationContext) { 244 // A rest parameter cannot have a binding pattern or an initializer, 245 // so let's just ignore it. 246 return parameter.dotDotDotToken ? parameter : 247 isBindingPattern(parameter.name) ? addDefaultValueAssignmentForBindingPattern(parameter, context) : 248 parameter.initializer ? addDefaultValueAssignmentForInitializer(parameter, parameter.name, parameter.initializer, context) : 249 parameter; 250 } 251 252 function addDefaultValueAssignmentForBindingPattern(parameter: ParameterDeclaration, context: TransformationContext) { 253 const { factory } = context; 254 context.addInitializationStatement( 255 factory.createVariableStatement( 256 /*modifiers*/ undefined, 257 factory.createVariableDeclarationList([ 258 factory.createVariableDeclaration( 259 parameter.name, 260 /*exclamationToken*/ undefined, 261 parameter.type, 262 parameter.initializer ? 263 factory.createConditionalExpression( 264 factory.createStrictEquality( 265 factory.getGeneratedNameForNode(parameter), 266 factory.createVoidZero() 267 ), 268 /*questionToken*/ undefined, 269 parameter.initializer, 270 /*colonToken*/ undefined, 271 factory.getGeneratedNameForNode(parameter) 272 ) : 273 factory.getGeneratedNameForNode(parameter) 274 ), 275 ]) 276 ) 277 ); 278 return factory.updateParameterDeclaration(parameter, 279 parameter.modifiers, 280 parameter.dotDotDotToken, 281 factory.getGeneratedNameForNode(parameter), 282 parameter.questionToken, 283 parameter.type, 284 /*initializer*/ undefined); 285 } 286 287 function addDefaultValueAssignmentForInitializer(parameter: ParameterDeclaration, name: Identifier, initializer: Expression, context: TransformationContext) { 288 const factory = context.factory; 289 context.addInitializationStatement( 290 factory.createIfStatement( 291 factory.createTypeCheck(factory.cloneNode(name), "undefined"), 292 setEmitFlags( 293 setTextRange( 294 factory.createBlock([ 295 factory.createExpressionStatement( 296 setEmitFlags( 297 setTextRange( 298 factory.createAssignment( 299 setEmitFlags(factory.cloneNode(name), EmitFlags.NoSourceMap), 300 setEmitFlags(initializer, EmitFlags.NoSourceMap | getEmitFlags(initializer) | EmitFlags.NoComments) 301 ), 302 parameter 303 ), 304 EmitFlags.NoComments 305 ) 306 ) 307 ]), 308 parameter 309 ), 310 EmitFlags.SingleLine | EmitFlags.NoTrailingSourceMap | EmitFlags.NoTokenSourceMaps | EmitFlags.NoComments 311 ) 312 ) 313 ); 314 return factory.updateParameterDeclaration(parameter, 315 parameter.modifiers, 316 parameter.dotDotDotToken, 317 parameter.name, 318 parameter.questionToken, 319 parameter.type, 320 /*initializer*/ undefined); 321 } 322 323 /** 324 * Resumes a suspended lexical environment and visits a function body, ending the lexical 325 * environment and merging hoisted declarations upon completion. 326 */ 327 export function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext): FunctionBody; 328 /** 329 * Resumes a suspended lexical environment and visits a function body, ending the lexical 330 * environment and merging hoisted declarations upon completion. 331 */ 332 export function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext): FunctionBody | undefined; 333 /** 334 * Resumes a suspended lexical environment and visits a concise body, ending the lexical 335 * environment and merging hoisted declarations upon completion. 336 */ 337 export function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext): ConciseBody; 338 /* @internal*/ export function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext, nodeVisitor?: NodeVisitor): FunctionBody; // eslint-disable-line @typescript-eslint/unified-signatures 339 /* @internal*/ export function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext, nodeVisitor?: NodeVisitor): FunctionBody | undefined; // eslint-disable-line @typescript-eslint/unified-signatures 340 /* @internal*/ export function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext, nodeVisitor?: NodeVisitor): ConciseBody; // eslint-disable-line @typescript-eslint/unified-signatures 341 export function visitFunctionBody(node: ConciseBody | undefined, visitor: Visitor, context: TransformationContext, nodeVisitor: NodeVisitor = visitNode): ConciseBody | undefined { 342 context.resumeLexicalEnvironment(); 343 const updated = nodeVisitor(node, visitor, isConciseBody); 344 const declarations = context.endLexicalEnvironment(); 345 if (some(declarations)) { 346 if (!updated) { 347 return context.factory.createBlock(declarations); 348 } 349 const block = context.factory.converters.convertToFunctionBlock(updated); 350 const statements = factory.mergeLexicalEnvironment(block.statements, declarations); 351 return context.factory.updateBlock(block, statements); 352 } 353 return updated; 354 } 355 356 /** 357 * Visits an iteration body, adding any block-scoped variables required by the transformation. 358 */ 359 export function visitIterationBody(body: Statement, visitor: Visitor, context: TransformationContext): Statement; 360 /* @internal */ 361 export function visitIterationBody(body: Statement, visitor: Visitor, context: TransformationContext, nodeVisitor?: NodeVisitor): Statement; // eslint-disable-line @typescript-eslint/unified-signatures 362 export function visitIterationBody(body: Statement, visitor: Visitor, context: TransformationContext, nodeVisitor: NodeVisitor = visitNode): Statement { 363 context.startBlockScope(); 364 const updated = nodeVisitor(body, visitor, isStatement, context.factory.liftToBlock); 365 const declarations = context.endBlockScope(); 366 if (some(declarations)) { 367 if (isBlock(updated)) { 368 declarations.push(...updated.statements); 369 return context.factory.updateBlock(updated, declarations); 370 } 371 declarations.push(updated); 372 return context.factory.createBlock(declarations); 373 } 374 return updated; 375 } 376 377 /** 378 * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place. 379 * 380 * @param node The Node whose children will be visited. 381 * @param visitor The callback used to visit each child. 382 * @param context A lexical environment context for the visitor. 383 */ 384 export function visitEachChild<T extends Node>(node: T, visitor: Visitor, context: TransformationContext): T; 385 /* @internal */ 386 export function visitEachChild<T extends Node>(node: T, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor, tokenVisitor?: Visitor, nodeVisitor?: NodeVisitor): T; // eslint-disable-line @typescript-eslint/unified-signatures 387 /** 388 * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place. 389 * 390 * @param node The Node whose children will be visited. 391 * @param visitor The callback used to visit each child. 392 * @param context A lexical environment context for the visitor. 393 */ 394 export function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined; 395 /* @internal */ 396 export function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor, tokenVisitor?: Visitor, nodeVisitor?: NodeVisitor): T | undefined; // eslint-disable-line @typescript-eslint/unified-signatures 397 export function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor = visitNodes, tokenVisitor?: Visitor, nodeVisitor: NodeVisitor = visitNode): T | undefined { 398 if (node === undefined) { 399 return undefined; 400 } 401 402 const fn = (visitEachChildTable as Record<SyntaxKind, VisitEachChildFunction<any> | undefined>)[node.kind]; 403 return fn === undefined ? node : fn(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor); 404 } 405 406 type VisitEachChildFunction<T extends Node> = (node: T, visitor: Visitor, context: TransformationContext, nodesVisitor: NodesVisitor, nodeVisitor: NodeVisitor, tokenVisitor: Visitor | undefined) => T; 407 408 // A type that correlates a `SyntaxKind` to a `VisitEachChildFunction<T>`, for nodes in the `HasChildren` union. 409 // This looks something like: 410 // 411 // { 412 // [SyntaxKind.Identifier]: VisitEachChildFunction<Identifier>; 413 // [SyntaxKind.QualifiedName]: VisitEachChildFunction<QualifiedName>; 414 // [SyntaxKind.ComputedPropertyName]: VisitEachChildFunction<ComputedPropertyName>; 415 // ... 416 // } 417 // 418 // This is then used as the expected type for `visitEachChildTable`. 419 type VisitEachChildTable = { [TNode in VisitEachChildNodes as TNode["kind"]]: VisitEachChildFunction<TNode> }; 420 421 // NOTE: Before you can add a new method to `visitEachChildTable`, you must first ensure the `Node` subtype you 422 // wish to add is defined in the `HasChildren` union in types.ts. 423 const visitEachChildTable: VisitEachChildTable = { 424 [SyntaxKind.Identifier]: function visitEachChildOfIdentifier(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 425 return context.factory.updateIdentifier(node, 426 nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration)); 427 }, 428 429 [SyntaxKind.QualifiedName]: function visitEachChildOfQualifiedName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 430 return context.factory.updateQualifiedName(node, 431 nodeVisitor(node.left, visitor, isEntityName), 432 nodeVisitor(node.right, visitor, isIdentifier)); 433 }, 434 435 [SyntaxKind.ComputedPropertyName]: function visitEachChildOfComputedPropertyName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 436 return context.factory.updateComputedPropertyName(node, 437 nodeVisitor(node.expression, visitor, isExpression)); 438 }, 439 440 // Signature elements 441 [SyntaxKind.TypeParameter]: function visitEachChildOfTypeParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 442 return context.factory.updateTypeParameterDeclaration(node, 443 nodesVisitor(node.modifiers, visitor, isModifier), 444 nodeVisitor(node.name, visitor, isIdentifier), 445 nodeVisitor(node.constraint, visitor, isTypeNode), 446 nodeVisitor(node.default, visitor, isTypeNode)); 447 }, 448 449 [SyntaxKind.Parameter]: function visitEachChildOfParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 450 return context.factory.updateParameterDeclaration(node, 451 nodesVisitor(node.modifiers, visitor, isModifierLike), 452 nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken), 453 nodeVisitor(node.name, visitor, isBindingName), 454 nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken), 455 nodeVisitor(node.type, visitor, isTypeNode), 456 nodeVisitor(node.initializer, visitor, isExpression)); 457 }, 458 459 [SyntaxKind.Decorator]: function visitEachChildOfDecorator(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 460 return context.factory.updateDecorator(node, 461 nodeVisitor(node.expression, visitor, isExpression), node.annotationDeclaration); 462 }, 463 464 // Type elements 465 [SyntaxKind.PropertySignature]: function visitEachChildOfPropertySignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 466 return context.factory.updatePropertySignature(node, 467 nodesVisitor(node.modifiers, visitor, isModifier), 468 nodeVisitor(node.name, visitor, isPropertyName), 469 nodeVisitor(node.questionToken, tokenVisitor, isToken), 470 nodeVisitor(node.type, visitor, isTypeNode)); 471 }, 472 473 [SyntaxKind.PropertyDeclaration]: function visitEachChildOfPropertyDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 474 return context.factory.updatePropertyDeclaration(node, 475 nodesVisitor(node.modifiers, visitor, isModifierLike), 476 nodeVisitor(node.name, visitor, isPropertyName), 477 // QuestionToken and ExclamationToken are mutually exclusive in PropertyDeclaration 478 nodeVisitor(node.questionToken ?? node.exclamationToken, tokenVisitor, isQuestionOrExclamationToken), 479 nodeVisitor(node.type, visitor, isTypeNode), 480 nodeVisitor(node.initializer, visitor, isExpression)); 481 }, 482 483 [SyntaxKind.AnnotationPropertyDeclaration]: function visitEachChildOfAnnotationPropertyDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 484 return context.factory.updateAnnotationPropertyDeclaration(node, 485 nodeVisitor(node.name, visitor, isPropertyName), 486 nodeVisitor(node.type, visitor, isTypeNode), 487 nodeVisitor(node.initializer, visitor, isExpression)); 488 }, 489 490 [SyntaxKind.MethodSignature]: function visitEachChildOfMethodSignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 491 return context.factory.updateMethodSignature(node, 492 nodesVisitor(node.modifiers, visitor, isModifier), 493 nodeVisitor(node.name, visitor, isPropertyName), 494 nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken), 495 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 496 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 497 nodeVisitor(node.type, visitor, isTypeNode)); 498 }, 499 500 [SyntaxKind.MethodDeclaration]: function visitEachChildOfMethodDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 501 return context.factory.updateMethodDeclaration(node, 502 nodesVisitor(node.modifiers, visitor, isModifierLike), 503 nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken), 504 nodeVisitor(node.name, visitor, isPropertyName), 505 nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken), 506 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 507 visitParameterList(node.parameters, visitor, context, nodesVisitor), 508 nodeVisitor(node.type, visitor, isTypeNode), 509 visitFunctionBody(node.body!, visitor, context, nodeVisitor)); 510 }, 511 512 [SyntaxKind.Constructor]: function visitEachChildOfConstructorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 513 return context.factory.updateConstructorDeclaration(node, 514 nodesVisitor(node.modifiers, visitor, isModifier), 515 visitParameterList(node.parameters, visitor, context, nodesVisitor), 516 visitFunctionBody(node.body!, visitor, context, nodeVisitor)); 517 }, 518 519 [SyntaxKind.GetAccessor]: function visitEachChildOfGetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 520 /** If the lexical environment is suspended, then we visit it as a type node*/ 521 if (context.isLexicalEnvironmentSuspended && context.isLexicalEnvironmentSuspended()) { 522 return context.factory.updateGetAccessorDeclaration(node, 523 nodesVisitor(node.modifiers, visitor, isModifierLike), 524 nodeVisitor(node.name, visitor, isPropertyName), 525 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 526 nodeVisitor(node.type, visitor, isTypeNode), 527 nodeVisitor(node.body, visitor, isConciseBody)); 528 } else { 529 return context.factory.updateGetAccessorDeclaration(node, 530 nodesVisitor(node.modifiers, visitor, isModifierLike), 531 nodeVisitor(node.name, visitor, isPropertyName), 532 visitParameterList(node.parameters, visitor, context, nodesVisitor), 533 nodeVisitor(node.type, visitor, isTypeNode), 534 visitFunctionBody(node.body!, visitor, context, nodeVisitor)); 535 } 536 }, 537 538 [SyntaxKind.SetAccessor]: function visitEachChildOfSetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 539 /** If the lexical environment is suspended, then we visit it as a type node*/ 540 if (context.isLexicalEnvironmentSuspended && context.isLexicalEnvironmentSuspended()) { 541 return context.factory.updateSetAccessorDeclaration(node, 542 nodesVisitor(node.modifiers, visitor, isModifierLike), 543 nodeVisitor(node.name, visitor, isPropertyName), 544 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 545 nodeVisitor(node.body, visitor, isConciseBody)); 546 } else { 547 return context.factory.updateSetAccessorDeclaration(node, 548 nodesVisitor(node.modifiers, visitor, isModifierLike), 549 nodeVisitor(node.name, visitor, isPropertyName), 550 visitParameterList(node.parameters, visitor, context, nodesVisitor), 551 visitFunctionBody(node.body!, visitor, context, nodeVisitor)); 552 } 553 }, 554 555 [SyntaxKind.ClassStaticBlockDeclaration]: function visitEachChildOfClassStaticBlockDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 556 context.startLexicalEnvironment(); 557 context.suspendLexicalEnvironment(); 558 return context.factory.updateClassStaticBlockDeclaration(node, 559 visitFunctionBody(node.body, visitor, context, nodeVisitor)); 560 }, 561 562 [SyntaxKind.CallSignature]: function visitEachChildOfCallSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 563 return context.factory.updateCallSignature(node, 564 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 565 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 566 nodeVisitor(node.type, visitor, isTypeNode)); 567 }, 568 569 [SyntaxKind.ConstructSignature]: function visitEachChildOfConstructSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 570 return context.factory.updateConstructSignature(node, 571 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 572 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 573 nodeVisitor(node.type, visitor, isTypeNode)); 574 }, 575 576 [SyntaxKind.IndexSignature]: function visitEachChildOfIndexSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 577 return context.factory.updateIndexSignature(node, 578 nodesVisitor(node.modifiers, visitor, isModifier), 579 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 580 nodeVisitor(node.type, visitor, isTypeNode)); 581 }, 582 583 // Types 584 [SyntaxKind.TypePredicate]: function visitEachChildOfTypePredicateNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 585 return context.factory.updateTypePredicateNode(node, 586 nodeVisitor(node.assertsModifier, visitor, isAssertsKeyword), 587 nodeVisitor(node.parameterName, visitor, isIdentifierOrThisTypeNode), 588 nodeVisitor(node.type, visitor, isTypeNode)); 589 }, 590 591 [SyntaxKind.TypeReference]: function visitEachChildOfTypeReferenceNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 592 return context.factory.updateTypeReferenceNode(node, 593 nodeVisitor(node.typeName, visitor, isEntityName), 594 nodesVisitor(node.typeArguments, visitor, isTypeNode)); 595 }, 596 597 [SyntaxKind.FunctionType]: function visitEachChildOfFunctionTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 598 return context.factory.updateFunctionTypeNode(node, 599 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 600 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 601 nodeVisitor(node.type, visitor, isTypeNode)); 602 }, 603 604 [SyntaxKind.ConstructorType]: function visitEachChildOfConstructorTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 605 return context.factory.updateConstructorTypeNode(node, 606 nodesVisitor(node.modifiers, visitor, isModifier), 607 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 608 nodesVisitor(node.parameters, visitor, isParameterDeclaration), 609 nodeVisitor(node.type, visitor, isTypeNode)); 610 }, 611 612 [SyntaxKind.TypeQuery]: function visitEachChildOfTypeQueryNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 613 return context.factory.updateTypeQueryNode(node, 614 nodeVisitor(node.exprName, visitor, isEntityName), 615 nodesVisitor(node.typeArguments, visitor, isTypeNode)); 616 }, 617 618 [SyntaxKind.TypeLiteral]: function visitEachChildOfTypeLiteralNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 619 return context.factory.updateTypeLiteralNode(node, 620 nodesVisitor(node.members, visitor, isTypeElement)); 621 }, 622 623 [SyntaxKind.ArrayType]: function visitEachChildOfArrayTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 624 return context.factory.updateArrayTypeNode(node, 625 nodeVisitor(node.elementType, visitor, isTypeNode)); 626 }, 627 628 [SyntaxKind.TupleType]: function visitEachChildOfTupleTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 629 return context.factory.updateTupleTypeNode(node, 630 nodesVisitor(node.elements, visitor, isTypeNode)); 631 }, 632 633 [SyntaxKind.OptionalType]: function visitEachChildOfOptionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 634 return context.factory.updateOptionalTypeNode(node, 635 nodeVisitor(node.type, visitor, isTypeNode)); 636 }, 637 638 [SyntaxKind.RestType]: function visitEachChildOfRestTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 639 return context.factory.updateRestTypeNode(node, 640 nodeVisitor(node.type, visitor, isTypeNode)); 641 }, 642 643 [SyntaxKind.UnionType]: function visitEachChildOfUnionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 644 return context.factory.updateUnionTypeNode(node, 645 nodesVisitor(node.types, visitor, isTypeNode)); 646 }, 647 648 [SyntaxKind.IntersectionType]: function visitEachChildOfIntersectionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 649 return context.factory.updateIntersectionTypeNode(node, 650 nodesVisitor(node.types, visitor, isTypeNode)); 651 }, 652 653 [SyntaxKind.ConditionalType]: function visitEachChildOfConditionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 654 return context.factory.updateConditionalTypeNode(node, 655 nodeVisitor(node.checkType, visitor, isTypeNode), 656 nodeVisitor(node.extendsType, visitor, isTypeNode), 657 nodeVisitor(node.trueType, visitor, isTypeNode), 658 nodeVisitor(node.falseType, visitor, isTypeNode)); 659 }, 660 661 [SyntaxKind.InferType]: function visitEachChildOfInferTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 662 return context.factory.updateInferTypeNode(node, 663 nodeVisitor(node.typeParameter, visitor, isTypeParameterDeclaration)); 664 }, 665 666 [SyntaxKind.ImportType]: function visitEachChildOfImportTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 667 return context.factory.updateImportTypeNode(node, 668 nodeVisitor(node.argument, visitor, isTypeNode), 669 nodeVisitor(node.assertions, visitor, isImportTypeAssertionContainer), 670 nodeVisitor(node.qualifier, visitor, isEntityName), 671 nodesVisitor(node.typeArguments, visitor, isTypeNode), 672 node.isTypeOf 673 ); 674 }, 675 676 [SyntaxKind.ImportTypeAssertionContainer]: function visitEachChildOfImportTypeAssertionContainer(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 677 return context.factory.updateImportTypeAssertionContainer(node, 678 nodeVisitor(node.assertClause, visitor, isAssertClause), 679 node.multiLine 680 ); 681 }, 682 683 [SyntaxKind.NamedTupleMember]: function visitEachChildOfNamedTupleMember(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 684 return context.factory.updateNamedTupleMember(node, 685 nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken), 686 nodeVisitor(node.name, visitor, isIdentifier), 687 nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken), 688 nodeVisitor(node.type, visitor, isTypeNode), 689 ); 690 }, 691 692 [SyntaxKind.ParenthesizedType]: function visitEachChildOfParenthesizedType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 693 return context.factory.updateParenthesizedType(node, 694 nodeVisitor(node.type, visitor, isTypeNode)); 695 }, 696 697 [SyntaxKind.TypeOperator]: function visitEachChildOfTypeOperatorNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 698 return context.factory.updateTypeOperatorNode(node, 699 nodeVisitor(node.type, visitor, isTypeNode)); 700 }, 701 702 [SyntaxKind.IndexedAccessType]: function visitEachChildOfIndexedAccessType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 703 return context.factory.updateIndexedAccessTypeNode(node, 704 nodeVisitor(node.objectType, visitor, isTypeNode), 705 nodeVisitor(node.indexType, visitor, isTypeNode)); 706 }, 707 708 [SyntaxKind.MappedType]: function visitEachChildOfMappedType(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 709 return context.factory.updateMappedTypeNode(node, 710 nodeVisitor(node.readonlyToken, tokenVisitor, isReadonlyKeywordOrPlusOrMinusToken), 711 nodeVisitor(node.typeParameter, visitor, isTypeParameterDeclaration), 712 nodeVisitor(node.nameType, visitor, isTypeNode), 713 nodeVisitor(node.questionToken, tokenVisitor, isQuestionOrPlusOrMinusToken), 714 nodeVisitor(node.type, visitor, isTypeNode), 715 nodesVisitor(node.members, visitor, isTypeElement)); 716 }, 717 718 [SyntaxKind.LiteralType]: function visitEachChildOfLiteralTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 719 return context.factory.updateLiteralTypeNode(node, 720 nodeVisitor(node.literal, visitor, isExpression)); 721 }, 722 723 [SyntaxKind.TemplateLiteralType]: function visitEachChildOfTemplateLiteralType(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 724 return context.factory.updateTemplateLiteralType(node, 725 nodeVisitor(node.head, visitor, isTemplateHead), 726 nodesVisitor(node.templateSpans, visitor, isTemplateLiteralTypeSpan)); 727 }, 728 729 [SyntaxKind.TemplateLiteralTypeSpan]: function visitEachChildOfTemplateLiteralTypeSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 730 return context.factory.updateTemplateLiteralTypeSpan(node, 731 nodeVisitor(node.type, visitor, isTypeNode), 732 nodeVisitor(node.literal, visitor, isTemplateMiddleOrTemplateTail)); 733 }, 734 735 // Binding patterns 736 [SyntaxKind.ObjectBindingPattern]: function visitEachChildOfObjectBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 737 return context.factory.updateObjectBindingPattern(node, 738 nodesVisitor(node.elements, visitor, isBindingElement)); 739 }, 740 741 [SyntaxKind.ArrayBindingPattern]: function visitEachChildOfArrayBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 742 return context.factory.updateArrayBindingPattern(node, 743 nodesVisitor(node.elements, visitor, isArrayBindingElement)); 744 }, 745 746 [SyntaxKind.BindingElement]: function visitEachChildOfBindingElement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 747 return context.factory.updateBindingElement(node, 748 nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken), 749 nodeVisitor(node.propertyName, visitor, isPropertyName), 750 nodeVisitor(node.name, visitor, isBindingName), 751 nodeVisitor(node.initializer, visitor, isExpression)); 752 }, 753 754 // Expression 755 [SyntaxKind.ArrayLiteralExpression]: function visitEachChildOfArrayLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 756 return context.factory.updateArrayLiteralExpression(node, 757 nodesVisitor(node.elements, visitor, isExpression)); 758 }, 759 760 [SyntaxKind.ObjectLiteralExpression]: function visitEachChildOfObjectLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 761 return context.factory.updateObjectLiteralExpression(node, 762 nodesVisitor(node.properties, visitor, isObjectLiteralElementLike)); 763 }, 764 765 [SyntaxKind.PropertyAccessExpression]: function visitEachChildOfPropertyAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 766 return isPropertyAccessChain(node) ? 767 context.factory.updatePropertyAccessChain(node, 768 nodeVisitor(node.expression, visitor, isExpression), 769 nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken), 770 nodeVisitor(node.name, visitor, isMemberName)) : 771 context.factory.updatePropertyAccessExpression(node, 772 nodeVisitor(node.expression, visitor, isExpression), 773 nodeVisitor(node.name, visitor, isMemberName)); 774 }, 775 776 [SyntaxKind.ElementAccessExpression]: function visitEachChildOfElementAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 777 return isElementAccessChain(node) ? 778 context.factory.updateElementAccessChain(node, 779 nodeVisitor(node.expression, visitor, isExpression), 780 nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken), 781 nodeVisitor(node.argumentExpression, visitor, isExpression)) : 782 context.factory.updateElementAccessExpression(node, 783 nodeVisitor(node.expression, visitor, isExpression), 784 nodeVisitor(node.argumentExpression, visitor, isExpression)); 785 }, 786 787 [SyntaxKind.CallExpression]: function visitEachChildOfCallExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 788 return isCallChain(node) ? 789 context.factory.updateCallChain(node, 790 nodeVisitor(node.expression, visitor, isExpression), 791 nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken), 792 nodesVisitor(node.typeArguments, visitor, isTypeNode), 793 nodesVisitor(node.arguments, visitor, isExpression)) : 794 context.factory.updateCallExpression(node, 795 nodeVisitor(node.expression, visitor, isExpression), 796 nodesVisitor(node.typeArguments, visitor, isTypeNode), 797 nodesVisitor(node.arguments, visitor, isExpression)); 798 }, 799 800 [SyntaxKind.EtsComponentExpression]: function visitEachChildOfEtsComponentExpression(node, visitor, context, nodesVisitor, nodeVisitor) { 801 return context.factory.updateEtsComponentExpression(node, 802 nodeVisitor(node.expression, visitor, isExpression), 803 //nodesVisitor(node.typeArguments, visitor, isTypeNode), 804 nodesVisitor(node.arguments, visitor, isExpression), 805 nodeVisitor(node.body, visitor, isBlock)); 806 }, 807 808 [SyntaxKind.NewExpression]: function visitEachChildOfNewExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 809 return context.factory.updateNewExpression(node, 810 nodeVisitor(node.expression, visitor, isExpression), 811 nodesVisitor(node.typeArguments, visitor, isTypeNode), 812 nodesVisitor(node.arguments, visitor, isExpression)); 813 }, 814 815 [SyntaxKind.TaggedTemplateExpression]: function visitEachChildOfTaggedTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 816 return context.factory.updateTaggedTemplateExpression(node, 817 nodeVisitor(node.tag, visitor, isExpression), 818 nodesVisitor(node.typeArguments, visitor, isTypeNode), 819 nodeVisitor(node.template, visitor, isTemplateLiteral)); 820 }, 821 822 [SyntaxKind.TypeAssertionExpression]: function visitEachChildOfTypeAssertionExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 823 return context.factory.updateTypeAssertion(node, 824 nodeVisitor(node.type, visitor, isTypeNode), 825 nodeVisitor(node.expression, visitor, isExpression)); 826 }, 827 828 [SyntaxKind.ParenthesizedExpression]: function visitEachChildOfParenthesizedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 829 return context.factory.updateParenthesizedExpression(node, 830 nodeVisitor(node.expression, visitor, isExpression)); 831 }, 832 833 [SyntaxKind.FunctionExpression]: function visitEachChildOfFunctionExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 834 return context.factory.updateFunctionExpression(node, 835 nodesVisitor(node.modifiers, visitor, isModifier), 836 nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken), 837 nodeVisitor(node.name, visitor, isIdentifier), 838 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 839 visitParameterList(node.parameters, visitor, context, nodesVisitor), 840 nodeVisitor(node.type, visitor, isTypeNode), 841 visitFunctionBody(node.body, visitor, context, nodeVisitor)); 842 }, 843 844 [SyntaxKind.ArrowFunction]: function visitEachChildOfArrowFunction(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 845 return context.factory.updateArrowFunction(node, 846 nodesVisitor(node.modifiers, visitor, isModifier), 847 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 848 visitParameterList(node.parameters, visitor, context, nodesVisitor), 849 nodeVisitor(node.type, visitor, isTypeNode), 850 nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, isEqualsGreaterThanToken), 851 visitFunctionBody(node.body, visitor, context, nodeVisitor)); 852 }, 853 854 [SyntaxKind.DeleteExpression]: function visitEachChildOfDeleteExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 855 return context.factory.updateDeleteExpression(node, 856 nodeVisitor(node.expression, visitor, isExpression)); 857 }, 858 859 [SyntaxKind.TypeOfExpression]: function visitEachChildOfTypeOfExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 860 return context.factory.updateTypeOfExpression(node, 861 nodeVisitor(node.expression, visitor, isExpression)); 862 }, 863 864 [SyntaxKind.VoidExpression]: function visitEachChildOfVoidExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 865 return context.factory.updateVoidExpression(node, 866 nodeVisitor(node.expression, visitor, isExpression)); 867 }, 868 869 [SyntaxKind.AwaitExpression]: function visitEachChildOfAwaitExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 870 return context.factory.updateAwaitExpression(node, 871 nodeVisitor(node.expression, visitor, isExpression)); 872 }, 873 874 [SyntaxKind.PrefixUnaryExpression]: function visitEachChildOfPrefixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 875 return context.factory.updatePrefixUnaryExpression(node, 876 nodeVisitor(node.operand, visitor, isExpression)); 877 }, 878 879 [SyntaxKind.PostfixUnaryExpression]: function visitEachChildOfPostfixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 880 return context.factory.updatePostfixUnaryExpression(node, 881 nodeVisitor(node.operand, visitor, isExpression)); 882 }, 883 884 [SyntaxKind.BinaryExpression]: function visitEachChildOfBinaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 885 return context.factory.updateBinaryExpression(node, 886 nodeVisitor(node.left, visitor, isExpression), 887 nodeVisitor(node.operatorToken, tokenVisitor, isBinaryOperatorToken), 888 nodeVisitor(node.right, visitor, isExpression)); 889 }, 890 891 [SyntaxKind.ConditionalExpression]: function visitEachChildOfConditionalExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 892 return context.factory.updateConditionalExpression(node, 893 nodeVisitor(node.condition, visitor, isExpression), 894 nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken), 895 nodeVisitor(node.whenTrue, visitor, isExpression), 896 nodeVisitor(node.colonToken, tokenVisitor, isColonToken), 897 nodeVisitor(node.whenFalse, visitor, isExpression)); 898 }, 899 900 [SyntaxKind.TemplateExpression]: function visitEachChildOfTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 901 return context.factory.updateTemplateExpression(node, 902 nodeVisitor(node.head, visitor, isTemplateHead), 903 nodesVisitor(node.templateSpans, visitor, isTemplateSpan)); 904 }, 905 906 [SyntaxKind.YieldExpression]: function visitEachChildOfYieldExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 907 return context.factory.updateYieldExpression(node, 908 nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken), 909 nodeVisitor(node.expression, visitor, isExpression)); 910 }, 911 912 [SyntaxKind.SpreadElement]: function visitEachChildOfSpreadElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 913 return context.factory.updateSpreadElement(node, 914 nodeVisitor(node.expression, visitor, isExpression)); 915 }, 916 917 [SyntaxKind.ClassExpression]: function visitEachChildOfClassExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 918 return context.factory.updateClassExpression(node, 919 nodesVisitor(node.modifiers, visitor, isModifierLike), 920 nodeVisitor(node.name, visitor, isIdentifier), 921 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 922 nodesVisitor(node.heritageClauses, visitor, isHeritageClause), 923 nodesVisitor(node.members, visitor, isClassElement)); 924 }, 925 926 [SyntaxKind.ExpressionWithTypeArguments]: function visitEachChildOfExpressionWithTypeArguments(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 927 return context.factory.updateExpressionWithTypeArguments(node, 928 nodeVisitor(node.expression, visitor, isExpression), 929 nodesVisitor(node.typeArguments, visitor, isTypeNode)); 930 }, 931 932 [SyntaxKind.AsExpression]: function visitEachChildOfAsExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 933 return context.factory.updateAsExpression(node, 934 nodeVisitor(node.expression, visitor, isExpression), 935 nodeVisitor(node.type, visitor, isTypeNode)); 936 }, 937 938 [SyntaxKind.SatisfiesExpression]: function visitEachChildOfSatisfiesExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 939 return context.factory.updateSatisfiesExpression(node, 940 nodeVisitor(node.expression, visitor, isExpression), 941 nodeVisitor(node.type, visitor, isTypeNode)); 942 }, 943 944 [SyntaxKind.NonNullExpression]: function visitEachChildOfNonNullExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 945 return isOptionalChain(node) ? 946 context.factory.updateNonNullChain(node, 947 nodeVisitor(node.expression, visitor, isExpression)) : 948 context.factory.updateNonNullExpression(node, 949 nodeVisitor(node.expression, visitor, isExpression)); 950 }, 951 952 [SyntaxKind.MetaProperty]: function visitEachChildOfMetaProperty(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 953 return context.factory.updateMetaProperty(node, 954 nodeVisitor(node.name, visitor, isIdentifier)); 955 }, 956 957 // Misc 958 [SyntaxKind.TemplateSpan]: function visitEachChildOfTemplateSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 959 return context.factory.updateTemplateSpan(node, 960 nodeVisitor(node.expression, visitor, isExpression), 961 nodeVisitor(node.literal, visitor, isTemplateMiddleOrTemplateTail)); 962 }, 963 964 // Element 965 [SyntaxKind.Block]: function visitEachChildOfBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 966 return context.factory.updateBlock(node, 967 nodesVisitor(node.statements, visitor, isStatement)); 968 }, 969 970 [SyntaxKind.VariableStatement]: function visitEachChildOfVariableStatement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 971 return context.factory.updateVariableStatement(node, 972 nodesVisitor(node.modifiers, visitor, isModifier), 973 nodeVisitor(node.declarationList, visitor, isVariableDeclarationList)); 974 }, 975 976 [SyntaxKind.ExpressionStatement]: function visitEachChildOfExpressionStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 977 return context.factory.updateExpressionStatement(node, 978 nodeVisitor(node.expression, visitor, isExpression)); 979 }, 980 981 [SyntaxKind.IfStatement]: function visitEachChildOfIfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 982 return context.factory.updateIfStatement(node, 983 nodeVisitor(node.expression, visitor, isExpression), 984 nodeVisitor(node.thenStatement, visitor, isStatement, context.factory.liftToBlock), 985 nodeVisitor(node.elseStatement, visitor, isStatement, context.factory.liftToBlock)); 986 }, 987 988 [SyntaxKind.DoStatement]: function visitEachChildOfDoStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 989 return context.factory.updateDoStatement(node, 990 visitIterationBody(node.statement, visitor, context, nodeVisitor), 991 nodeVisitor(node.expression, visitor, isExpression)); 992 }, 993 994 [SyntaxKind.WhileStatement]: function visitEachChildOfWhileStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 995 return context.factory.updateWhileStatement(node, 996 nodeVisitor(node.expression, visitor, isExpression), 997 visitIterationBody(node.statement, visitor, context, nodeVisitor)); 998 }, 999 1000 [SyntaxKind.ForStatement]: function visitEachChildOfForStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1001 return context.factory.updateForStatement(node, 1002 nodeVisitor(node.initializer, visitor, isForInitializer), 1003 nodeVisitor(node.condition, visitor, isExpression), 1004 nodeVisitor(node.incrementor, visitor, isExpression), 1005 visitIterationBody(node.statement, visitor, context, nodeVisitor)); 1006 }, 1007 1008 [SyntaxKind.ForInStatement]: function visitEachChildOfForInStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1009 return context.factory.updateForInStatement(node, 1010 nodeVisitor(node.initializer, visitor, isForInitializer), 1011 nodeVisitor(node.expression, visitor, isExpression), 1012 visitIterationBody(node.statement, visitor, context, nodeVisitor)); 1013 }, 1014 1015 [SyntaxKind.ForOfStatement]: function visitEachChildOfForOfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 1016 return context.factory.updateForOfStatement(node, 1017 nodeVisitor(node.awaitModifier, tokenVisitor, isAwaitKeyword), 1018 nodeVisitor(node.initializer, visitor, isForInitializer), 1019 nodeVisitor(node.expression, visitor, isExpression), 1020 visitIterationBody(node.statement, visitor, context, nodeVisitor)); 1021 }, 1022 1023 [SyntaxKind.ContinueStatement]: function visitEachChildOfContinueStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1024 return context.factory.updateContinueStatement(node, 1025 nodeVisitor(node.label, visitor, isIdentifier)); 1026 }, 1027 1028 [SyntaxKind.BreakStatement]: function visitEachChildOfBreakStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1029 return context.factory.updateBreakStatement(node, 1030 nodeVisitor(node.label, visitor, isIdentifier)); 1031 }, 1032 1033 [SyntaxKind.ReturnStatement]: function visitEachChildOfReturnStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1034 return context.factory.updateReturnStatement(node, 1035 nodeVisitor(node.expression, visitor, isExpression)); 1036 }, 1037 1038 [SyntaxKind.WithStatement]: function visitEachChildOfWithStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1039 return context.factory.updateWithStatement(node, 1040 nodeVisitor(node.expression, visitor, isExpression), 1041 nodeVisitor(node.statement, visitor, isStatement, context.factory.liftToBlock)); 1042 }, 1043 1044 [SyntaxKind.SwitchStatement]: function visitEachChildOfSwitchStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1045 return context.factory.updateSwitchStatement(node, 1046 nodeVisitor(node.expression, visitor, isExpression), 1047 nodeVisitor(node.caseBlock, visitor, isCaseBlock)); 1048 }, 1049 1050 [SyntaxKind.LabeledStatement]: function visitEachChildOfLabeledStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1051 return context.factory.updateLabeledStatement(node, 1052 nodeVisitor(node.label, visitor, isIdentifier), 1053 nodeVisitor(node.statement, visitor, isStatement, context.factory.liftToBlock)); 1054 }, 1055 1056 [SyntaxKind.ThrowStatement]: function visitEachChildOfThrowStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1057 return context.factory.updateThrowStatement(node, 1058 nodeVisitor(node.expression, visitor, isExpression)); 1059 }, 1060 1061 [SyntaxKind.TryStatement]: function visitEachChildOfTryStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1062 return context.factory.updateTryStatement(node, 1063 nodeVisitor(node.tryBlock, visitor, isBlock), 1064 nodeVisitor(node.catchClause, visitor, isCatchClause), 1065 nodeVisitor(node.finallyBlock, visitor, isBlock)); 1066 }, 1067 1068 [SyntaxKind.VariableDeclaration]: function visitEachChildOfVariableDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { 1069 return context.factory.updateVariableDeclaration(node, 1070 nodeVisitor(node.name, visitor, isBindingName), 1071 nodeVisitor(node.exclamationToken, tokenVisitor, isExclamationToken), 1072 nodeVisitor(node.type, visitor, isTypeNode), 1073 nodeVisitor(node.initializer, visitor, isExpression)); 1074 }, 1075 1076 [SyntaxKind.VariableDeclarationList]: function visitEachChildOfVariableDeclarationList(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1077 return context.factory.updateVariableDeclarationList(node, 1078 nodesVisitor(node.declarations, visitor, isVariableDeclaration)); 1079 }, 1080 1081 [SyntaxKind.FunctionDeclaration]: function visitEachChildOfFunctionDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { 1082 return context.factory.updateFunctionDeclaration(node, 1083 nodesVisitor(node.modifiers, visitor, isModifier), 1084 nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken), 1085 nodeVisitor(node.name, visitor, isIdentifier), 1086 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 1087 visitParameterList(node.parameters, visitor, context, nodesVisitor), 1088 nodeVisitor(node.type, visitor, isTypeNode), 1089 visitFunctionBody(node.body, visitor, context, nodeVisitor)); 1090 }, 1091 1092 [SyntaxKind.ClassDeclaration]: function visitEachChildOfClassDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1093 return context.factory.updateClassDeclaration(node, 1094 nodesVisitor(node.modifiers, visitor, isModifierLike), 1095 nodeVisitor(node.name, visitor, isIdentifier), 1096 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 1097 nodesVisitor(node.heritageClauses, visitor, isHeritageClause), 1098 nodesVisitor(node.members, visitor, isClassElement)); 1099 }, 1100 1101 [SyntaxKind.StructDeclaration]: function visitEachChildOfStructDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1102 return context.factory.updateStructDeclaration(node, 1103 nodesVisitor(node.modifiers, visitor, isModifier), 1104 nodeVisitor(node.name, visitor, isIdentifier), 1105 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 1106 nodesVisitor(node.heritageClauses, visitor, isHeritageClause), 1107 nodesVisitor(node.members, visitor, isClassElement)); 1108 }, 1109 1110 [SyntaxKind.AnnotationDeclaration]: function visitEachChildOfAnnotationDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1111 return context.factory.updateAnnotationDeclaration(node, 1112 nodesVisitor(node.modifiers, visitor, isModifier), 1113 nodeVisitor(node.name, visitor, isIdentifier), 1114 nodesVisitor(node.members, visitor, isAnnotationElement)); 1115 }, 1116 1117 [SyntaxKind.InterfaceDeclaration]: function visitEachChildOfInterfaceDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1118 return context.factory.updateInterfaceDeclaration(node, 1119 nodesVisitor(node.modifiers, visitor, isModifier), 1120 nodeVisitor(node.name, visitor, isIdentifier), 1121 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 1122 nodesVisitor(node.heritageClauses, visitor, isHeritageClause), 1123 nodesVisitor(node.members, visitor, isTypeElement)); 1124 }, 1125 1126 [SyntaxKind.TypeAliasDeclaration]: function visitEachChildOfTypeAliasDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1127 return context.factory.updateTypeAliasDeclaration(node, 1128 nodesVisitor(node.modifiers, visitor, isModifier), 1129 nodeVisitor(node.name, visitor, isIdentifier), 1130 nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), 1131 nodeVisitor(node.type, visitor, isTypeNode)); 1132 }, 1133 1134 [SyntaxKind.EnumDeclaration]: function visitEachChildOfEnumDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1135 return context.factory.updateEnumDeclaration(node, 1136 nodesVisitor(node.modifiers, visitor, isModifier), 1137 nodeVisitor(node.name, visitor, isIdentifier), 1138 nodesVisitor(node.members, visitor, isEnumMember)); 1139 }, 1140 1141 [SyntaxKind.ModuleDeclaration]: function visitEachChildOfModuleDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1142 return context.factory.updateModuleDeclaration(node, 1143 nodesVisitor(node.modifiers, visitor, isModifier), 1144 nodeVisitor(node.name, visitor, isModuleName), 1145 nodeVisitor(node.body, visitor, isModuleBody)); 1146 }, 1147 1148 [SyntaxKind.ModuleBlock]: function visitEachChildOfModuleBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1149 return context.factory.updateModuleBlock(node, 1150 nodesVisitor(node.statements, visitor, isStatement)); 1151 }, 1152 1153 [SyntaxKind.CaseBlock]: function visitEachChildOfCaseBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1154 return context.factory.updateCaseBlock(node, 1155 nodesVisitor(node.clauses, visitor, isCaseOrDefaultClause)); 1156 }, 1157 1158 [SyntaxKind.NamespaceExportDeclaration]: function visitEachChildOfNamespaceExportDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1159 return context.factory.updateNamespaceExportDeclaration(node, 1160 nodeVisitor(node.name, visitor, isIdentifier)); 1161 }, 1162 1163 [SyntaxKind.ImportEqualsDeclaration]: function visitEachChildOfImportEqualsDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1164 return context.factory.updateImportEqualsDeclaration(node, 1165 nodesVisitor(node.modifiers, visitor, isModifier), 1166 node.isTypeOnly, 1167 nodeVisitor(node.name, visitor, isIdentifier), 1168 nodeVisitor(node.moduleReference, visitor, isModuleReference)); 1169 }, 1170 1171 [SyntaxKind.ImportDeclaration]: function visitEachChildOfImportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1172 return context.factory.updateImportDeclaration(node, 1173 nodesVisitor(node.modifiers, visitor, isModifier), 1174 nodeVisitor(node.importClause, visitor, isImportClause), 1175 nodeVisitor(node.moduleSpecifier, visitor, isExpression), 1176 nodeVisitor(node.assertClause, visitor, isAssertClause)); 1177 }, 1178 1179 [SyntaxKind.AssertClause]: function visitEachChildOfAssertClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1180 return context.factory.updateAssertClause(node, 1181 nodesVisitor(node.elements, visitor, isAssertEntry), 1182 node.multiLine); 1183 }, 1184 1185 [SyntaxKind.AssertEntry]: function visitEachChildOfAssertEntry(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1186 return context.factory.updateAssertEntry(node, 1187 nodeVisitor(node.name, visitor, isAssertionKey), 1188 nodeVisitor(node.value, visitor, isExpression)); 1189 }, 1190 1191 [SyntaxKind.ImportClause]: function visitEachChildOfImportClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1192 return context.factory.updateImportClause(node, 1193 node.isTypeOnly, 1194 nodeVisitor(node.name, visitor, isIdentifier), 1195 nodeVisitor(node.namedBindings, visitor, isNamedImportBindings)); 1196 }, 1197 1198 [SyntaxKind.NamespaceImport]: function visitEachChildOfNamespaceImport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1199 return context.factory.updateNamespaceImport(node, 1200 nodeVisitor(node.name, visitor, isIdentifier)); 1201 }, 1202 1203 [SyntaxKind.NamespaceExport]: function visitEachChildOfNamespaceExport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1204 return context.factory.updateNamespaceExport(node, 1205 nodeVisitor(node.name, visitor, isIdentifier)); 1206 }, 1207 1208 [SyntaxKind.NamedImports]: function visitEachChildOfNamedImports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1209 return context.factory.updateNamedImports(node, 1210 nodesVisitor(node.elements, visitor, isImportSpecifier)); 1211 }, 1212 1213 [SyntaxKind.ImportSpecifier]: function visitEachChildOfImportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1214 return context.factory.updateImportSpecifier(node, 1215 node.isTypeOnly, 1216 nodeVisitor(node.propertyName, visitor, isIdentifier), 1217 nodeVisitor(node.name, visitor, isIdentifier)); 1218 }, 1219 1220 [SyntaxKind.ExportAssignment]: function visitEachChildOfExportAssignment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1221 return context.factory.updateExportAssignment(node, 1222 nodesVisitor(node.modifiers, visitor, isModifier), 1223 nodeVisitor(node.expression, visitor, isExpression)); 1224 }, 1225 1226 [SyntaxKind.ExportDeclaration]: function visitEachChildOfExportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1227 return context.factory.updateExportDeclaration(node, 1228 nodesVisitor(node.modifiers, visitor, isModifier), 1229 node.isTypeOnly, 1230 nodeVisitor(node.exportClause, visitor, isNamedExportBindings), 1231 nodeVisitor(node.moduleSpecifier, visitor, isExpression), 1232 nodeVisitor(node.assertClause, visitor, isAssertClause)); 1233 }, 1234 1235 [SyntaxKind.NamedExports]: function visitEachChildOfNamedExports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1236 return context.factory.updateNamedExports(node, 1237 nodesVisitor(node.elements, visitor, isExportSpecifier)); 1238 }, 1239 1240 [SyntaxKind.ExportSpecifier]: function visitEachChildOfExportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1241 return context.factory.updateExportSpecifier(node, 1242 node.isTypeOnly, 1243 nodeVisitor(node.propertyName, visitor, isIdentifier), 1244 nodeVisitor(node.name, visitor, isIdentifier)); 1245 }, 1246 1247 // Module references 1248 [SyntaxKind.ExternalModuleReference]: function visitEachChildOfExternalModuleReference(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1249 return context.factory.updateExternalModuleReference(node, 1250 nodeVisitor(node.expression, visitor, isExpression)); 1251 }, 1252 1253 // JSX 1254 [SyntaxKind.JsxElement]: function visitEachChildOfJsxElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1255 return context.factory.updateJsxElement(node, 1256 nodeVisitor(node.openingElement, visitor, isJsxOpeningElement), 1257 nodesVisitor(node.children, visitor, isJsxChild), 1258 nodeVisitor(node.closingElement, visitor, isJsxClosingElement)); 1259 }, 1260 1261 [SyntaxKind.JsxSelfClosingElement]: function visitEachChildOfJsxSelfClosingElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1262 return context.factory.updateJsxSelfClosingElement(node, 1263 nodeVisitor(node.tagName, visitor, isJsxTagNameExpression), 1264 nodesVisitor(node.typeArguments, visitor, isTypeNode), 1265 nodeVisitor(node.attributes, visitor, isJsxAttributes)); 1266 }, 1267 1268 [SyntaxKind.JsxOpeningElement]: function visitEachChildOfJsxOpeningElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1269 return context.factory.updateJsxOpeningElement(node, 1270 nodeVisitor(node.tagName, visitor, isJsxTagNameExpression), 1271 nodesVisitor(node.typeArguments, visitor, isTypeNode), 1272 nodeVisitor(node.attributes, visitor, isJsxAttributes)); 1273 }, 1274 1275 [SyntaxKind.JsxClosingElement]: function visitEachChildOfJsxClosingElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1276 return context.factory.updateJsxClosingElement(node, 1277 nodeVisitor(node.tagName, visitor, isJsxTagNameExpression)); 1278 }, 1279 1280 [SyntaxKind.JsxFragment]: function visitEachChildOfJsxFragment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1281 return context.factory.updateJsxFragment(node, 1282 nodeVisitor(node.openingFragment, visitor, isJsxOpeningFragment), 1283 nodesVisitor(node.children, visitor, isJsxChild), 1284 nodeVisitor(node.closingFragment, visitor, isJsxClosingFragment)); 1285 }, 1286 1287 [SyntaxKind.JsxAttribute]: function visitEachChildOfJsxAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1288 return context.factory.updateJsxAttribute(node, 1289 nodeVisitor(node.name, visitor, isIdentifier), 1290 nodeVisitor(node.initializer, visitor, isStringLiteralOrJsxExpression)); 1291 }, 1292 1293 [SyntaxKind.JsxAttributes]: function visitEachChildOfJsxAttributes(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1294 return context.factory.updateJsxAttributes(node, 1295 nodesVisitor(node.properties, visitor, isJsxAttributeLike)); 1296 }, 1297 1298 [SyntaxKind.JsxSpreadAttribute]: function visitEachChildOfJsxSpreadAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1299 return context.factory.updateJsxSpreadAttribute(node, 1300 nodeVisitor(node.expression, visitor, isExpression)); 1301 }, 1302 1303 [SyntaxKind.JsxExpression]: function visitEachChildOfJsxExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1304 return context.factory.updateJsxExpression(node, 1305 nodeVisitor(node.expression, visitor, isExpression)); 1306 }, 1307 1308 // Clauses 1309 [SyntaxKind.CaseClause]: function visitEachChildOfCaseClause(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { 1310 return context.factory.updateCaseClause(node, 1311 nodeVisitor(node.expression, visitor, isExpression), 1312 nodesVisitor(node.statements, visitor, isStatement)); 1313 }, 1314 1315 [SyntaxKind.DefaultClause]: function visitEachChildOfDefaultClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1316 return context.factory.updateDefaultClause(node, 1317 nodesVisitor(node.statements, visitor, isStatement)); 1318 }, 1319 1320 [SyntaxKind.HeritageClause]: function visitEachChildOfHeritageClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1321 return context.factory.updateHeritageClause(node, 1322 nodesVisitor(node.types, visitor, isExpressionWithTypeArguments)); 1323 }, 1324 1325 [SyntaxKind.CatchClause]: function visitEachChildOfCatchClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1326 return context.factory.updateCatchClause(node, 1327 nodeVisitor(node.variableDeclaration, visitor, isVariableDeclaration), 1328 nodeVisitor(node.block, visitor, isBlock)); 1329 }, 1330 1331 // Property assignments 1332 [SyntaxKind.PropertyAssignment]: function visitEachChildOfPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1333 return context.factory.updatePropertyAssignment(node, 1334 nodeVisitor(node.name, visitor, isPropertyName), 1335 nodeVisitor(node.initializer, visitor, isExpression)); 1336 }, 1337 1338 [SyntaxKind.ShorthandPropertyAssignment]: function visitEachChildOfShorthandPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1339 return context.factory.updateShorthandPropertyAssignment(node, 1340 nodeVisitor(node.name, visitor, isIdentifier), 1341 nodeVisitor(node.objectAssignmentInitializer, visitor, isExpression)); 1342 }, 1343 1344 [SyntaxKind.SpreadAssignment]: function visitEachChildOfSpreadAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1345 return context.factory.updateSpreadAssignment(node, 1346 nodeVisitor(node.expression, visitor, isExpression)); 1347 }, 1348 1349 // Enum 1350 [SyntaxKind.EnumMember]: function visitEachChildOfEnumMember(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1351 return context.factory.updateEnumMember(node, 1352 nodeVisitor(node.name, visitor, isPropertyName), 1353 nodeVisitor(node.initializer, visitor, isExpression)); 1354 }, 1355 1356 // Top-level nodes 1357 [SyntaxKind.SourceFile]: function visitEachChildOfSourceFile(node, visitor, context, _nodesVisitor, _nodeVisitor, _tokenVisitor) { 1358 return context.factory.updateSourceFile(node, 1359 visitLexicalEnvironment(node.statements, visitor, context)); 1360 }, 1361 1362 // Transformation nodes 1363 [SyntaxKind.PartiallyEmittedExpression]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { 1364 return context.factory.updatePartiallyEmittedExpression(node, 1365 nodeVisitor(node.expression, visitor, isExpression)); 1366 }, 1367 1368 [SyntaxKind.CommaListExpression]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { 1369 return context.factory.updateCommaListExpression(node, 1370 nodesVisitor(node.elements, visitor, isExpression)); 1371 }, 1372 }; 1373 1374 /** 1375 * Extracts the single node from a NodeArray. 1376 * 1377 * @param nodes The NodeArray. 1378 */ 1379 function extractSingleNode(nodes: readonly Node[]): Node | undefined { 1380 Debug.assert(nodes.length <= 1, "Too many nodes written to output."); 1381 return singleOrUndefined(nodes); 1382 } 1383} 1384