From f671ea7574f2fd37fc18fbf23b55aaf6030e9fe4 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 8 Aug 2022 21:12:35 +0000 Subject: [PATCH 1/9] Swap `forEachChild` to use an array of functions instead of a `switch` statement. --- src/compiler/parser.ts | 1533 +++++++++++++++++++++++++--------------- 1 file changed, 977 insertions(+), 556 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index e30a73e093503..00d6502ae9b0d 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -95,6 +95,980 @@ namespace ts { return isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword && node.name.escapedText === "meta"; } + type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; + + const forEachChildTable = Array(SyntaxKind.Count); + + forEachChildTable[SyntaxKind.QualifiedName] = forEachQualifiedName; + + function forEachQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + } + forEachChildTable[SyntaxKind.TypeParameter] = forEachTypeParameter; + + function forEachTypeParameter(node: TypeParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.constraint) || + visitNode(cbNode, node.default) || + visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachShorthandPropertyAssignment; + + function forEachShorthandPropertyAssignment(node: ShorthandPropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.equalsToken) || + visitNode(cbNode, node.objectAssignmentInitializer); + } + forEachChildTable[SyntaxKind.SpreadAssignment] = forEachSpreadAssignment; + + function forEachSpreadAssignment(node: SpreadAssignment, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.Parameter] = forEachParameter; + + function forEachParameter(node: ParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.PropertyDeclaration] = forEachPropertyDeclaration; + + function forEachPropertyDeclaration(node: PropertyDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.PropertySignature] = forEachPropertySignature; + + function forEachPropertySignature(node: PropertySignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.PropertyAssignment] = forEachPropertyAssignment; + + function forEachPropertyAssignment(node: PropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.VariableDeclaration] = forEachVariableDeclaration; + + function forEachVariableDeclaration(node: VariableDeclaration, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.BindingElement] = forEachBindingElement; + + function forEachBindingElement(node: BindingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.IndexSignature] = forEachIndexSignature; + + function forEachIndexSignature(node: IndexSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.ConstructorType] = forEachConstructorType; + function forEachConstructorType(node: ConstructorTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.FunctionType] = forEachFunctionType; + + function forEachFunctionType(node: FunctionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.CallSignature] = forEachCallOrConstructSignature; + forEachChildTable[SyntaxKind.ConstructSignature] = forEachCallOrConstructSignature; + + function forEachCallOrConstructSignature(node: CallSignatureDeclaration | ConstructSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.MethodDeclaration] = forEachMethodDeclaration; + + function forEachMethodDeclaration(node: MethodDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.MethodSignature] = forEachMethodSignature; + + function forEachMethodSignature(node: MethodSignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.Constructor] = forEachConstructor; + + function forEachConstructor(node: ConstructorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.GetAccessor] = forEachGetAccessor; + + function forEachGetAccessor(node: GetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.SetAccessor] = forEachSetAccessor; + + function forEachSetAccessor(node: SetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.FunctionDeclaration] = forEachFunctionDeclaration; + + function forEachFunctionDeclaration(node: FunctionDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.FunctionExpression] = forEachFunctionExpression; + + function forEachFunctionExpression(node: FunctionExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.ArrowFunction] = forEachArrowFunction; + + function forEachArrowFunction(node: ArrowFunction, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.equalsGreaterThanToken) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.ClassStaticBlockDeclaration] = forEachClassStaticBlockDeclaration; + + function forEachClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.TypeReference] = forEachTypeReference; + + function forEachTypeReference(node: TypeReferenceNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.typeName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + } + forEachChildTable[SyntaxKind.TypePredicate] = forEachTypePredicate; + + function forEachTypePredicate(node: TypePredicateNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.assertsModifier) || + visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.TypeQuery] = forEachTypeQuery; + + function forEachTypeQuery(node: TypeQueryNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.exprName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + } + forEachChildTable[SyntaxKind.TypeLiteral] = forEachTypeLiteral; + + function forEachTypeLiteral(node: TypeLiteralNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.members); + } + forEachChildTable[SyntaxKind.ArrayType] = forEachArrayType; + + function forEachArrayType(node: ArrayTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.elementType); + } + forEachChildTable[SyntaxKind.TupleType] = forEachTupleType; + + function forEachTupleType(node: TupleTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.elements); + } + forEachChildTable[SyntaxKind.UnionType] = forEachUnionOrIntersectionType; + forEachChildTable[SyntaxKind.IntersectionType] = forEachUnionOrIntersectionType; + + function forEachUnionOrIntersectionType(node: UnionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.types); + } + forEachChildTable[SyntaxKind.ConditionalType] = forEachConditionalType; + + function forEachConditionalType(node: ConditionalTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.checkType) || + visitNode(cbNode, node.extendsType) || + visitNode(cbNode, node.trueType) || + visitNode(cbNode, node.falseType); + } + forEachChildTable[SyntaxKind.InferType] = forEachInferType; + + function forEachInferType(node: InferTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.typeParameter); + } + forEachChildTable[SyntaxKind.ImportType] = forEachImportType; + + function forEachImportType(node: ImportTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.argument) || + visitNode(cbNode, node.assertions) || + visitNode(cbNode, node.qualifier) || + visitNodes(cbNode, cbNodes, node.typeArguments); + } + forEachChildTable[SyntaxKind.ImportTypeAssertionContainer] = forEachImportTypeAssertionContainer; + + function forEachImportTypeAssertionContainer(node: ImportTypeAssertionContainer, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.assertClause); + } + forEachChildTable[SyntaxKind.ParenthesizedType] = forEachParenthesizedTypeOrTypeOperator; + forEachChildTable[SyntaxKind.TypeOperator] = forEachParenthesizedTypeOrTypeOperator; + + function forEachParenthesizedTypeOrTypeOperator(node: ParenthesizedTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, (node as ParenthesizedTypeNode | TypeOperatorNode).type); + } + forEachChildTable[SyntaxKind.IndexedAccessType] = forEachIndexedAccessType; + + function forEachIndexedAccessType(node: IndexedAccessTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.objectType) || + visitNode(cbNode, node.indexType); + } + forEachChildTable[SyntaxKind.MappedType] = forEachMappedType; + + function forEachMappedType(node: MappedTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.readonlyToken) || + visitNode(cbNode, node.typeParameter) || + visitNode(cbNode, node.nameType) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNodes(cbNode, cbNodes, node.members); + } + forEachChildTable[SyntaxKind.LiteralType] = forEachLiteralType; + + function forEachLiteralType(node: LiteralTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.literal); + } + forEachChildTable[SyntaxKind.NamedTupleMember] = forEachNamedTupleMember; + + function forEachNamedTupleMember(node: NamedTupleMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.ObjectBindingPattern] = forEachObjectOrArrayBindingPattern; + forEachChildTable[SyntaxKind.ArrayBindingPattern] = forEachObjectOrArrayBindingPattern; + + function forEachObjectOrArrayBindingPattern(node: ObjectBindingPattern, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.elements); + } + forEachChildTable[SyntaxKind.ArrayLiteralExpression] = forEachArrayLiteralExpression; + + function forEachArrayLiteralExpression(node: ArrayLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.elements); + } + forEachChildTable[SyntaxKind.ObjectLiteralExpression] = forEachObjectLiteralExpression; + + function forEachObjectLiteralExpression(node: ObjectLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.properties); + } + forEachChildTable[SyntaxKind.PropertyAccessExpression] = forEachPropertyAccessExpression; + + function forEachPropertyAccessExpression(node: PropertyAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.ElementAccessExpression] = forEachElementAccessExpression; + + function forEachElementAccessExpression(node: ElementAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.argumentExpression); + } + forEachChildTable[SyntaxKind.CallExpression] = forEachCallExpression; + forEachChildTable[SyntaxKind.NewExpression] = forEachCallExpression; + + function forEachCallExpression(node: CallExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNodes(cbNode, cbNodes, node.arguments); + } + forEachChildTable[SyntaxKind.TaggedTemplateExpression] = forEachTaggedTemplateExpression; + + function forEachTaggedTemplateExpression(node: TaggedTemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tag) || + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.template); + } + forEachChildTable[SyntaxKind.TypeAssertionExpression] = forEachTypeAssertionExpression; + + function forEachTypeAssertionExpression(node: TypeAssertion, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.ParenthesizedExpression] = forEachParenthesizedExpression; + + function forEachParenthesizedExpression(node: ParenthesizedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.DeleteExpression] = forEachDeleteExpression; + + function forEachDeleteExpression(node: DeleteExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.TypeOfExpression] = forEachTypeOfExpression; + + function forEachTypeOfExpression(node: TypeOfExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.VoidExpression] = forEachVoidExpression; + + function forEachVoidExpression(node: VoidExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.PrefixUnaryExpression] = forEachPrefixUnaryExpression; + + function forEachPrefixUnaryExpression(node: PrefixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.operand); + } + forEachChildTable[SyntaxKind.YieldExpression] = forEachYieldExpression; + + function forEachYieldExpression(node: YieldExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.AwaitExpression] = forEachAwaitExpression; + + function forEachAwaitExpression(node: AwaitExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.PostfixUnaryExpression] = forEachPostfixUnaryExpression; + + function forEachPostfixUnaryExpression(node: PostfixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.operand); + } + forEachChildTable[SyntaxKind.BinaryExpression] = forEachBinaryExpression; + + function forEachBinaryExpression(node: BinaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.operatorToken) || + visitNode(cbNode, node.right); + } + forEachChildTable[SyntaxKind.AsExpression] = forEachAsExpression; + + function forEachAsExpression(node: AsExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.NonNullExpression] = forEachNonNullExpression; + + function forEachNonNullExpression(node: NonNullExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.MetaProperty] = forEachMetaProperty; + + function forEachMetaProperty(node: MetaProperty, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.ConditionalExpression] = forEachConditionalExpression; + + function forEachConditionalExpression(node: ConditionalExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.condition) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.whenTrue) || + visitNode(cbNode, node.colonToken) || + visitNode(cbNode, node.whenFalse); + } + forEachChildTable[SyntaxKind.SpreadElement] = forEachSpreadElement; + + function forEachSpreadElement(node: SpreadElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.Block] = forEachBlock; + forEachChildTable[SyntaxKind.ModuleBlock] = forEachBlock; + + function forEachBlock(node: Block, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.statements); + } + forEachChildTable[SyntaxKind.SourceFile] = forEachSourceFile; + + function forEachSourceFile(node: SourceFile, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.statements) || + visitNode(cbNode, node.endOfFileToken); + } + forEachChildTable[SyntaxKind.VariableStatement] = forEachVariableStatement; + + function forEachVariableStatement(node: VariableStatement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.declarationList); + } + forEachChildTable[SyntaxKind.VariableDeclarationList] = forEachVariableDeclarationList; + + function forEachVariableDeclarationList(node: VariableDeclarationList, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.declarations); + } + forEachChildTable[SyntaxKind.ExpressionStatement] = forEachExpressionStatement; + + function forEachExpressionStatement(node: ExpressionStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.IfStatement] = forEachIfStatement; + + function forEachIfStatement(node: IfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.thenStatement) || + visitNode(cbNode, node.elseStatement); + } + forEachChildTable[SyntaxKind.DoStatement] = forEachDoStatement; + + function forEachDoStatement(node: DoStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.statement) || + visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.WhileStatement] = forEachWhileStatement; + + function forEachWhileStatement(node: WhileStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + } + forEachChildTable[SyntaxKind.ForStatement] = forEachForStatement; + + function forEachForStatement(node: ForStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.condition) || + visitNode(cbNode, node.incrementor) || + visitNode(cbNode, node.statement); + } + forEachChildTable[SyntaxKind.ForInStatement] = forEachForInStatement; + + function forEachForInStatement(node: ForInStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + } + forEachChildTable[SyntaxKind.ForOfStatement] = forEachForOfStatement; + + function forEachForOfStatement(node: ForOfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.awaitModifier) || + visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + } + forEachChildTable[SyntaxKind.ContinueStatement] = forEachContinueStatement; + forEachChildTable[SyntaxKind.BreakStatement] = forEachContinueStatement; + + function forEachContinueStatement(node: ContinueStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.label); + } + forEachChildTable[SyntaxKind.ReturnStatement] = forEachReturnStatement; + + function forEachReturnStatement(node: ReturnStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.WithStatement] = forEachWithStatement; + + function forEachWithStatement(node: WithStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + } + forEachChildTable[SyntaxKind.SwitchStatement] = forEachSwitchStatement; + + function forEachSwitchStatement(node: SwitchStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.caseBlock); + } + forEachChildTable[SyntaxKind.CaseBlock] = forEachCaseBlock; + + function forEachCaseBlock(node: CaseBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.clauses); + } + forEachChildTable[SyntaxKind.CaseClause] = forEachCaseClause; + + function forEachCaseClause(node: CaseClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.statements); + } + forEachChildTable[SyntaxKind.DefaultClause] = forEachDefaultClause; + + function forEachDefaultClause(node: DefaultClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.statements); + } + forEachChildTable[SyntaxKind.LabeledStatement] = forEachLabeledStatement; + + function forEachLabeledStatement(node: LabeledStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + } + forEachChildTable[SyntaxKind.ThrowStatement] = forEachThrowStatement; + + function forEachThrowStatement(node: ThrowStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.TryStatement] = forEachTryStatement; + + function forEachTryStatement(node: TryStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tryBlock) || + visitNode(cbNode, node.catchClause) || + visitNode(cbNode, node.finallyBlock); + } + forEachChildTable[SyntaxKind.CatchClause] = forEachCatchClause; + + function forEachCatchClause(node: CatchClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.variableDeclaration) || + visitNode(cbNode, node.block); + } + forEachChildTable[SyntaxKind.Decorator] = forEachDecorator; + + function forEachDecorator(node: Decorator, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.ClassDeclaration] = forEachClassDeclarationOrExpression; + forEachChildTable[SyntaxKind.ClassExpression] = forEachClassDeclarationOrExpression; + + function forEachClassDeclarationOrExpression(node: ClassDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + } + forEachChildTable[SyntaxKind.InterfaceDeclaration] = forEachInterfaceDeclaration; + + function forEachInterfaceDeclaration(node: InterfaceDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + } + forEachChildTable[SyntaxKind.TypeAliasDeclaration] = forEachTypeAliasDeclaration; + + function forEachTypeAliasDeclaration(node: TypeAliasDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.EnumDeclaration] = forEachEnumDeclaration; + + function forEachEnumDeclaration(node: EnumDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.members); + } + forEachChildTable[SyntaxKind.EnumMember] = forEachEnumMember; + + function forEachEnumMember(node: EnumMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.ModuleDeclaration] = forEachModuleDeclaration; + + function forEachModuleDeclaration(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + } + forEachChildTable[SyntaxKind.ImportEqualsDeclaration] = forEachImportEqualsDeclaration; + + function forEachImportEqualsDeclaration(node: ImportEqualsDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.moduleReference); + } + forEachChildTable[SyntaxKind.ImportDeclaration] = forEachImportDeclaration; + + function forEachImportDeclaration(node: ImportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier) || + visitNode(cbNode, node.assertClause); + } + forEachChildTable[SyntaxKind.ImportClause] = forEachImportClause; + + function forEachImportClause(node: ImportClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + } + forEachChildTable[SyntaxKind.AssertClause] = forEachAssertClause; + + function forEachAssertClause(node: AssertClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.elements); + } + forEachChildTable[SyntaxKind.AssertEntry] = forEachAssertEntry; + + function forEachAssertEntry(node: AssertEntry, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.value); + } + forEachChildTable[SyntaxKind.NamespaceExportDeclaration] = forEachNamespaceExportDeclaration; + + function forEachNamespaceExportDeclaration(node: NamespaceExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.NamespaceImport] = forEachNamespaceImport; + + function forEachNamespaceImport(node: NamespaceImport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.NamespaceExport] = forEachNamespaceExport; + + function forEachNamespaceExport(node: NamespaceExport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.NamedImports] = forEachNamedImportsOrExports; + forEachChildTable[SyntaxKind.NamedExports] = forEachNamedImportsOrExports; + + function forEachNamedImportsOrExports(node: NamedImports, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.elements); + } + forEachChildTable[SyntaxKind.ExportDeclaration] = forEachExportDeclaration; + + function forEachExportDeclaration(node: ExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier) || + visitNode(cbNode, node.assertClause); + } + forEachChildTable[SyntaxKind.ImportSpecifier] = forEachImportOrExportSpecifier; + forEachChildTable[SyntaxKind.ExportSpecifier] = forEachImportOrExportSpecifier; + + function forEachImportOrExportSpecifier(node: ImportSpecifier, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.ExportAssignment] = forEachExportAssignment; + + function forEachExportAssignment(node: ExportAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.TemplateExpression] = forEachTemplateExpression; + + function forEachTemplateExpression(node: TemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.head) || + visitNodes(cbNode, cbNodes, node.templateSpans); + } + forEachChildTable[SyntaxKind.TemplateSpan] = forEachTemplateSpan; + + function forEachTemplateSpan(node: TemplateSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.literal); + } + forEachChildTable[SyntaxKind.TemplateLiteralType] = forEachTemplateLiteralType; + + function forEachTemplateLiteralType(node: TemplateLiteralTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.head) || + visitNodes(cbNode, cbNodes, node.templateSpans); + } + forEachChildTable[SyntaxKind.TemplateLiteralTypeSpan] = forEachTemplateLiteralTypeSpan; + + function forEachTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.literal); + } + forEachChildTable[SyntaxKind.ComputedPropertyName] = forEachComputedPropertyName; + + function forEachComputedPropertyName(node: ComputedPropertyName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.HeritageClause] = forEachHeritageClause; + + function forEachHeritageClause(node: HeritageClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.types); + } + forEachChildTable[SyntaxKind.ExpressionWithTypeArguments] = forEachExpressionWithTypeArguments; + + function forEachExpressionWithTypeArguments(node: ExpressionWithTypeArguments, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.typeArguments); + } + forEachChildTable[SyntaxKind.ExternalModuleReference] = forEachExternalModuleReference; + + function forEachExternalModuleReference(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.MissingDeclaration] = forEachMissingDeclaration; + + function forEachMissingDeclaration(node: MissingDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.decorators) || + visitNodes(cbNode, cbNodes, node.modifiers); + } + forEachChildTable[SyntaxKind.CommaListExpression] = forEachCommaListExpression; + + function forEachCommaListExpression(node: CommaListExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.elements); + } + + forEachChildTable[SyntaxKind.JsxElement] = forEachJsxElement; + + function forEachJsxElement(node: JsxElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.openingElement) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingElement); + } + forEachChildTable[SyntaxKind.JsxFragment] = forEachJsxFragment; + + function forEachJsxFragment(node: JsxFragment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.openingFragment) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingFragment); + } + forEachChildTable[SyntaxKind.JsxSelfClosingElement] = forEachJsxOpeningOrSelfClosingElement; + forEachChildTable[SyntaxKind.JsxOpeningElement] = forEachJsxOpeningOrSelfClosingElement; + + function forEachJsxOpeningOrSelfClosingElement(node: JsxOpeningLikeElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.attributes); + } + forEachChildTable[SyntaxKind.JsxAttributes] = forEachJsxAttributes; + + function forEachJsxAttributes(node: JsxAttributes, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.properties); + } + forEachChildTable[SyntaxKind.JsxAttribute] = forEachJsxAttribute; + + function forEachJsxAttribute(node: JsxAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + } + forEachChildTable[SyntaxKind.JsxSpreadAttribute] = forEachJsxSpreadAttribute; + + function forEachJsxSpreadAttribute(node: JsxSpreadAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.JsxExpression] = forEachJsxExpression; + + function forEachJsxExpression(node: JsxExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.expression); + } + forEachChildTable[SyntaxKind.JsxClosingElement] = forEachJsxClosingElement; + + function forEachJsxClosingElement(node: JsxClosingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName); + } + + forEachChildTable[SyntaxKind.OptionalType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.RestType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocTypeExpression] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocNonNullableType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocNullableType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocOptionalType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocVariadicType] = forEachOptionalRestOrJSDocParameterModifier; + + function forEachOptionalRestOrJSDocParameterModifier(node: OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.JSDocFunctionType] = forEachJSDocFunctionType; + + function forEachJSDocFunctionType(node: JSDocFunctionType, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.JSDoc] = forEachJSDoc; + + function forEachJSDoc(node: JSDoc, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + || visitNodes(cbNode, cbNodes, node.tags); + } + forEachChildTable[SyntaxKind.JSDocSeeTag] = forEachJSDocSeeTag; + + function forEachJSDocSeeTag(node: JSDocSeeTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.name) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocNameReference] = forEachJSDocNameReference; + + function forEachJSDocNameReference(node: JSDocNameReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.JSDocMemberName] = forEachJSDocMemberName; + + function forEachJSDocMemberName(node: JSDocMemberName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + } + forEachChildTable[SyntaxKind.JSDocParameterTag] = forEachJSDocParameterOrPropertyTag; + forEachChildTable[SyntaxKind.JSDocPropertyTag] = forEachJSDocParameterOrPropertyTag; + + function forEachJSDocParameterOrPropertyTag(node: JSDocParameterTag | JSDocPropertyTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + (node.isNameFirst + ? visitNode(cbNode, node.name) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + : visitNode(cbNode, node.typeExpression) || + visitNode(cbNode, node.name) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); + } + forEachChildTable[SyntaxKind.JSDocAuthorTag] = forEachJSDocAuthorTag; + + function forEachJSDocAuthorTag(node: JSDocAuthorTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocImplementsTag] = forEachJSDocImplementsTag; + + function forEachJSDocImplementsTag(node: JSDocImplementsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocAugmentsTag] = forEachJSDocAugmentsTag; + + function forEachJSDocAugmentsTag(node: JSDocAugmentsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocTemplateTag] = forEachJSDocTemplateTag; + + function forEachJSDocTemplateTag(node: JSDocTemplateTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.constraint) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocTypedefTag] = forEachJSDocTypedefTag; + + function forEachJSDocTypedefTag(node: JSDocTypedefTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + (node.typeExpression && + node.typeExpression.kind === SyntaxKind.JSDocTypeExpression + ? visitNode(cbNode, node.typeExpression) || + visitNode(cbNode, node.fullName) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + : visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); + } + forEachChildTable[SyntaxKind.JSDocCallbackTag] = forEachJSDocCallbackTag; + + function forEachJSDocCallbackTag(node: JSDocCallbackTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocReturnTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocTypeTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocThisTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocEnumTag] = forEachJSDocReturnTag; + + function forEachJSDocReturnTag(node: JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.JSDocSignature] = forEachJSDocSignature; + + function forEachJSDocSignature(node: JSDocSignature, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return forEach(node.typeParameters, cbNode) || + forEach(node.parameters, cbNode) || + visitNode(cbNode, node.type); + } + forEachChildTable[SyntaxKind.JSDocLink] = forEachJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocLinkCode] = forEachJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocLinkPlain] = forEachJSDocLinkCodeOrPlain; + function forEachJSDocLinkCodeOrPlain(node: JSDocLink | JSDocLinkCode | JSDocLinkPlain, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.name); + } + forEachChildTable[SyntaxKind.JSDocTypeLiteral] = forEachJSDocTypeLiteral; + + function forEachJSDocTypeLiteral(node: JSDocTypeLiteral, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return forEach(node.jsDocPropertyTags, cbNode); + } + + forEachChildTable[SyntaxKind.JSDocTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocClassTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocPublicTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocPrivateTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocProtectedTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocReadonlyTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocDeprecatedTag] = forEachJSDocTag; + + function forEachJSDocTag(node: JSDocTag | JSDocClassTag | JSDocPublicTag | JSDocPrivateTag | JSDocProtectedTag | JSDocReadonlyTag | JSDocDeprecatedTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.tagName) + || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + forEachChildTable[SyntaxKind.PartiallyEmittedExpression] = forEachPartiallyEmittedExpression; + + function forEachPartiallyEmittedExpression(node: PartiallyEmittedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + return visitNode(cbNode, node.expression); + } + /** * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, @@ -109,564 +1083,11 @@ namespace ts { * that they appear in the source code. The language service depends on this property to locate nodes by position. */ export function forEachChild(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { - if (!node || node.kind <= SyntaxKind.LastToken) { + if (node === undefined || node.kind <= SyntaxKind.LastToken) { return; } - switch (node.kind) { - case SyntaxKind.QualifiedName: - return visitNode(cbNode, (node as QualifiedName).left) || - visitNode(cbNode, (node as QualifiedName).right); - case SyntaxKind.TypeParameter: - return visitNodes(cbNode, cbNodes, (node as TypeParameterDeclaration).modifiers) || - visitNode(cbNode, (node as TypeParameterDeclaration).name) || - visitNode(cbNode, (node as TypeParameterDeclaration).constraint) || - visitNode(cbNode, (node as TypeParameterDeclaration).default) || - visitNode(cbNode, (node as TypeParameterDeclaration).expression); - case SyntaxKind.ShorthandPropertyAssignment: - return visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).decorators) || - visitNodes(cbNode, cbNodes, (node as ShorthandPropertyAssignment).modifiers) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).name) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).questionToken) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).exclamationToken) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).equalsToken) || - visitNode(cbNode, (node as ShorthandPropertyAssignment).objectAssignmentInitializer); - case SyntaxKind.SpreadAssignment: - return visitNode(cbNode, (node as SpreadAssignment).expression); - case SyntaxKind.Parameter: - return visitNodes(cbNode, cbNodes, (node as ParameterDeclaration).modifiers) || - visitNode(cbNode, (node as ParameterDeclaration).dotDotDotToken) || - visitNode(cbNode, (node as ParameterDeclaration).name) || - visitNode(cbNode, (node as ParameterDeclaration).questionToken) || - visitNode(cbNode, (node as ParameterDeclaration).type) || - visitNode(cbNode, (node as ParameterDeclaration).initializer); - case SyntaxKind.PropertyDeclaration: - return visitNodes(cbNode, cbNodes, (node as PropertyDeclaration).modifiers) || - visitNode(cbNode, (node as PropertyDeclaration).name) || - visitNode(cbNode, (node as PropertyDeclaration).questionToken) || - visitNode(cbNode, (node as PropertyDeclaration).exclamationToken) || - visitNode(cbNode, (node as PropertyDeclaration).type) || - visitNode(cbNode, (node as PropertyDeclaration).initializer); - case SyntaxKind.PropertySignature: - return visitNodes(cbNode, cbNodes, (node as PropertySignature).modifiers) || - visitNode(cbNode, (node as PropertySignature).name) || - visitNode(cbNode, (node as PropertySignature).questionToken) || - visitNode(cbNode, (node as PropertySignature).type) || - visitNode(cbNode, (node as PropertySignature).initializer); - case SyntaxKind.PropertyAssignment: - return visitNodes(cbNode, cbNodes, (node as PropertyAssignment).decorators) || - visitNodes(cbNode, cbNodes, (node as PropertyAssignment).modifiers) || - visitNode(cbNode, (node as PropertyAssignment).name) || - visitNode(cbNode, (node as PropertyAssignment).questionToken) || - visitNode(cbNode, (node as PropertyAssignment).exclamationToken) || - visitNode(cbNode, (node as PropertyAssignment).initializer); - case SyntaxKind.VariableDeclaration: - return visitNode(cbNode, (node as VariableDeclaration).name) || - visitNode(cbNode, (node as VariableDeclaration).exclamationToken) || - visitNode(cbNode, (node as VariableDeclaration).type) || - visitNode(cbNode, (node as VariableDeclaration).initializer); - case SyntaxKind.BindingElement: - return visitNode(cbNode, (node as BindingElement).dotDotDotToken) || - visitNode(cbNode, (node as BindingElement).propertyName) || - visitNode(cbNode, (node as BindingElement).name) || - visitNode(cbNode, (node as BindingElement).initializer); - case SyntaxKind.IndexSignature: - return visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).modifiers) || - visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as IndexSignatureDeclaration).parameters) || - visitNode(cbNode, (node as IndexSignatureDeclaration).type); - case SyntaxKind.ConstructorType: - return visitNodes(cbNode, cbNodes, (node as ConstructorTypeNode).modifiers) || - visitNodes(cbNode, cbNodes, (node as ConstructorTypeNode).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ConstructorTypeNode).parameters) || - visitNode(cbNode, (node as ConstructorTypeNode).type); - case SyntaxKind.FunctionType: - return visitNodes(cbNode, cbNodes, (node as FunctionTypeNode).modifiers) || - visitNodes(cbNode, cbNodes, (node as FunctionTypeNode).typeParameters) || - visitNodes(cbNode, cbNodes, (node as FunctionTypeNode).parameters) || - visitNode(cbNode, (node as FunctionTypeNode).type); - case SyntaxKind.CallSignature: - case SyntaxKind.ConstructSignature: - return visitNodes(cbNode, cbNodes, (node as CallSignatureDeclaration | ConstructSignatureDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as CallSignatureDeclaration | ConstructSignatureDeclaration).parameters) || - visitNode(cbNode, (node as CallSignatureDeclaration | ConstructSignatureDeclaration).type); - case SyntaxKind.MethodDeclaration: - return visitNodes(cbNode, cbNodes, (node as MethodDeclaration).modifiers) || - visitNode(cbNode, (node as MethodDeclaration).asteriskToken) || - visitNode(cbNode, (node as MethodDeclaration).name) || - visitNode(cbNode, (node as MethodDeclaration).questionToken) || - visitNode(cbNode, (node as MethodDeclaration).exclamationToken) || - visitNodes(cbNode, cbNodes, (node as MethodDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as MethodDeclaration).parameters) || - visitNode(cbNode, (node as MethodDeclaration).type) || - visitNode(cbNode, (node as MethodDeclaration).body); - case SyntaxKind.MethodSignature: - return visitNodes(cbNode, cbNodes, (node as MethodSignature).modifiers) || - visitNode(cbNode, (node as MethodSignature).name) || - visitNode(cbNode, (node as MethodSignature).questionToken) || - visitNodes(cbNode, cbNodes, (node as MethodSignature).typeParameters) || - visitNodes(cbNode, cbNodes, (node as MethodSignature).parameters) || - visitNode(cbNode, (node as MethodSignature).type); - case SyntaxKind.Constructor: - return visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).modifiers) || - visitNode(cbNode, (node as ConstructorDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ConstructorDeclaration).parameters) || - visitNode(cbNode, (node as ConstructorDeclaration).type) || - visitNode(cbNode, (node as ConstructorDeclaration).body); - case SyntaxKind.GetAccessor: - return visitNodes(cbNode, cbNodes, (node as GetAccessorDeclaration).modifiers) || - visitNode(cbNode, (node as GetAccessorDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as GetAccessorDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as GetAccessorDeclaration).parameters) || - visitNode(cbNode, (node as GetAccessorDeclaration).type) || - visitNode(cbNode, (node as GetAccessorDeclaration).body); - case SyntaxKind.SetAccessor: - return visitNodes(cbNode, cbNodes, (node as SetAccessorDeclaration).modifiers) || - visitNode(cbNode, (node as SetAccessorDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as SetAccessorDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as SetAccessorDeclaration).parameters) || - visitNode(cbNode, (node as SetAccessorDeclaration).type) || - visitNode(cbNode, (node as SetAccessorDeclaration).body); - case SyntaxKind.FunctionDeclaration: - return visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).modifiers) || - visitNode(cbNode, (node as FunctionDeclaration).asteriskToken) || - visitNode(cbNode, (node as FunctionDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as FunctionDeclaration).parameters) || - visitNode(cbNode, (node as FunctionDeclaration).type) || - visitNode(cbNode, (node as FunctionDeclaration).body); - case SyntaxKind.FunctionExpression: - return visitNodes(cbNode, cbNodes, (node as FunctionExpression).modifiers) || - visitNode(cbNode, (node as FunctionExpression).asteriskToken) || - visitNode(cbNode, (node as FunctionExpression).name) || - visitNodes(cbNode, cbNodes, (node as FunctionExpression).typeParameters) || - visitNodes(cbNode, cbNodes, (node as FunctionExpression).parameters) || - visitNode(cbNode, (node as FunctionExpression).type) || - visitNode(cbNode, (node as FunctionExpression).body); - case SyntaxKind.ArrowFunction: - return visitNodes(cbNode, cbNodes, (node as ArrowFunction).modifiers) || - visitNodes(cbNode, cbNodes, (node as ArrowFunction).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ArrowFunction).parameters) || - visitNode(cbNode, (node as ArrowFunction).type) || - visitNode(cbNode, (node as ArrowFunction).equalsGreaterThanToken) || - visitNode(cbNode, (node as ArrowFunction).body); - case SyntaxKind.ClassStaticBlockDeclaration: - return visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as ClassStaticBlockDeclaration).modifiers) || - visitNode(cbNode, (node as ClassStaticBlockDeclaration).body); - case SyntaxKind.TypeReference: - return visitNode(cbNode, (node as TypeReferenceNode).typeName) || - visitNodes(cbNode, cbNodes, (node as TypeReferenceNode).typeArguments); - case SyntaxKind.TypePredicate: - return visitNode(cbNode, (node as TypePredicateNode).assertsModifier) || - visitNode(cbNode, (node as TypePredicateNode).parameterName) || - visitNode(cbNode, (node as TypePredicateNode).type); - case SyntaxKind.TypeQuery: - return visitNode(cbNode, (node as TypeQueryNode).exprName) || - visitNodes(cbNode, cbNodes, (node as TypeQueryNode).typeArguments); - case SyntaxKind.TypeLiteral: - return visitNodes(cbNode, cbNodes, (node as TypeLiteralNode).members); - case SyntaxKind.ArrayType: - return visitNode(cbNode, (node as ArrayTypeNode).elementType); - case SyntaxKind.TupleType: - return visitNodes(cbNode, cbNodes, (node as TupleTypeNode).elements); - case SyntaxKind.UnionType: - case SyntaxKind.IntersectionType: - return visitNodes(cbNode, cbNodes, (node as UnionOrIntersectionTypeNode).types); - case SyntaxKind.ConditionalType: - return visitNode(cbNode, (node as ConditionalTypeNode).checkType) || - visitNode(cbNode, (node as ConditionalTypeNode).extendsType) || - visitNode(cbNode, (node as ConditionalTypeNode).trueType) || - visitNode(cbNode, (node as ConditionalTypeNode).falseType); - case SyntaxKind.InferType: - return visitNode(cbNode, (node as InferTypeNode).typeParameter); - case SyntaxKind.ImportType: - return visitNode(cbNode, (node as ImportTypeNode).argument) || - visitNode(cbNode, (node as ImportTypeNode).assertions) || - visitNode(cbNode, (node as ImportTypeNode).qualifier) || - visitNodes(cbNode, cbNodes, (node as ImportTypeNode).typeArguments); - case SyntaxKind.ImportTypeAssertionContainer: - return visitNode(cbNode, (node as ImportTypeAssertionContainer).assertClause); - case SyntaxKind.ParenthesizedType: - case SyntaxKind.TypeOperator: - return visitNode(cbNode, (node as ParenthesizedTypeNode | TypeOperatorNode).type); - case SyntaxKind.IndexedAccessType: - return visitNode(cbNode, (node as IndexedAccessTypeNode).objectType) || - visitNode(cbNode, (node as IndexedAccessTypeNode).indexType); - case SyntaxKind.MappedType: - return visitNode(cbNode, (node as MappedTypeNode).readonlyToken) || - visitNode(cbNode, (node as MappedTypeNode).typeParameter) || - visitNode(cbNode, (node as MappedTypeNode).nameType) || - visitNode(cbNode, (node as MappedTypeNode).questionToken) || - visitNode(cbNode, (node as MappedTypeNode).type) || - visitNodes(cbNode, cbNodes, (node as MappedTypeNode).members); - case SyntaxKind.LiteralType: - return visitNode(cbNode, (node as LiteralTypeNode).literal); - case SyntaxKind.NamedTupleMember: - return visitNode(cbNode, (node as NamedTupleMember).dotDotDotToken) || - visitNode(cbNode, (node as NamedTupleMember).name) || - visitNode(cbNode, (node as NamedTupleMember).questionToken) || - visitNode(cbNode, (node as NamedTupleMember).type); - case SyntaxKind.ObjectBindingPattern: - case SyntaxKind.ArrayBindingPattern: - return visitNodes(cbNode, cbNodes, (node as BindingPattern).elements); - case SyntaxKind.ArrayLiteralExpression: - return visitNodes(cbNode, cbNodes, (node as ArrayLiteralExpression).elements); - case SyntaxKind.ObjectLiteralExpression: - return visitNodes(cbNode, cbNodes, (node as ObjectLiteralExpression).properties); - case SyntaxKind.PropertyAccessExpression: - return visitNode(cbNode, (node as PropertyAccessExpression).expression) || - visitNode(cbNode, (node as PropertyAccessExpression).questionDotToken) || - visitNode(cbNode, (node as PropertyAccessExpression).name); - case SyntaxKind.ElementAccessExpression: - return visitNode(cbNode, (node as ElementAccessExpression).expression) || - visitNode(cbNode, (node as ElementAccessExpression).questionDotToken) || - visitNode(cbNode, (node as ElementAccessExpression).argumentExpression); - case SyntaxKind.CallExpression: - case SyntaxKind.NewExpression: - return visitNode(cbNode, (node as CallExpression).expression) || - visitNode(cbNode, (node as CallExpression).questionDotToken) || - visitNodes(cbNode, cbNodes, (node as CallExpression).typeArguments) || - visitNodes(cbNode, cbNodes, (node as CallExpression).arguments); - case SyntaxKind.TaggedTemplateExpression: - return visitNode(cbNode, (node as TaggedTemplateExpression).tag) || - visitNode(cbNode, (node as TaggedTemplateExpression).questionDotToken) || - visitNodes(cbNode, cbNodes, (node as TaggedTemplateExpression).typeArguments) || - visitNode(cbNode, (node as TaggedTemplateExpression).template); - case SyntaxKind.TypeAssertionExpression: - return visitNode(cbNode, (node as TypeAssertion).type) || - visitNode(cbNode, (node as TypeAssertion).expression); - case SyntaxKind.ParenthesizedExpression: - return visitNode(cbNode, (node as ParenthesizedExpression).expression); - case SyntaxKind.DeleteExpression: - return visitNode(cbNode, (node as DeleteExpression).expression); - case SyntaxKind.TypeOfExpression: - return visitNode(cbNode, (node as TypeOfExpression).expression); - case SyntaxKind.VoidExpression: - return visitNode(cbNode, (node as VoidExpression).expression); - case SyntaxKind.PrefixUnaryExpression: - return visitNode(cbNode, (node as PrefixUnaryExpression).operand); - case SyntaxKind.YieldExpression: - return visitNode(cbNode, (node as YieldExpression).asteriskToken) || - visitNode(cbNode, (node as YieldExpression).expression); - case SyntaxKind.AwaitExpression: - return visitNode(cbNode, (node as AwaitExpression).expression); - case SyntaxKind.PostfixUnaryExpression: - return visitNode(cbNode, (node as PostfixUnaryExpression).operand); - case SyntaxKind.BinaryExpression: - return visitNode(cbNode, (node as BinaryExpression).left) || - visitNode(cbNode, (node as BinaryExpression).operatorToken) || - visitNode(cbNode, (node as BinaryExpression).right); - case SyntaxKind.AsExpression: - return visitNode(cbNode, (node as AsExpression).expression) || - visitNode(cbNode, (node as AsExpression).type); - case SyntaxKind.NonNullExpression: - return visitNode(cbNode, (node as NonNullExpression).expression); - case SyntaxKind.MetaProperty: - return visitNode(cbNode, (node as MetaProperty).name); - case SyntaxKind.ConditionalExpression: - return visitNode(cbNode, (node as ConditionalExpression).condition) || - visitNode(cbNode, (node as ConditionalExpression).questionToken) || - visitNode(cbNode, (node as ConditionalExpression).whenTrue) || - visitNode(cbNode, (node as ConditionalExpression).colonToken) || - visitNode(cbNode, (node as ConditionalExpression).whenFalse); - case SyntaxKind.SpreadElement: - return visitNode(cbNode, (node as SpreadElement).expression); - case SyntaxKind.Block: - case SyntaxKind.ModuleBlock: - return visitNodes(cbNode, cbNodes, (node as Block).statements); - case SyntaxKind.SourceFile: - return visitNodes(cbNode, cbNodes, (node as SourceFile).statements) || - visitNode(cbNode, (node as SourceFile).endOfFileToken); - case SyntaxKind.VariableStatement: - return visitNodes(cbNode, cbNodes, (node as VariableStatement).decorators) || - visitNodes(cbNode, cbNodes, (node as VariableStatement).modifiers) || - visitNode(cbNode, (node as VariableStatement).declarationList); - case SyntaxKind.VariableDeclarationList: - return visitNodes(cbNode, cbNodes, (node as VariableDeclarationList).declarations); - case SyntaxKind.ExpressionStatement: - return visitNode(cbNode, (node as ExpressionStatement).expression); - case SyntaxKind.IfStatement: - return visitNode(cbNode, (node as IfStatement).expression) || - visitNode(cbNode, (node as IfStatement).thenStatement) || - visitNode(cbNode, (node as IfStatement).elseStatement); - case SyntaxKind.DoStatement: - return visitNode(cbNode, (node as DoStatement).statement) || - visitNode(cbNode, (node as DoStatement).expression); - case SyntaxKind.WhileStatement: - return visitNode(cbNode, (node as WhileStatement).expression) || - visitNode(cbNode, (node as WhileStatement).statement); - case SyntaxKind.ForStatement: - return visitNode(cbNode, (node as ForStatement).initializer) || - visitNode(cbNode, (node as ForStatement).condition) || - visitNode(cbNode, (node as ForStatement).incrementor) || - visitNode(cbNode, (node as ForStatement).statement); - case SyntaxKind.ForInStatement: - return visitNode(cbNode, (node as ForInStatement).initializer) || - visitNode(cbNode, (node as ForInStatement).expression) || - visitNode(cbNode, (node as ForInStatement).statement); - case SyntaxKind.ForOfStatement: - return visitNode(cbNode, (node as ForOfStatement).awaitModifier) || - visitNode(cbNode, (node as ForOfStatement).initializer) || - visitNode(cbNode, (node as ForOfStatement).expression) || - visitNode(cbNode, (node as ForOfStatement).statement); - case SyntaxKind.ContinueStatement: - case SyntaxKind.BreakStatement: - return visitNode(cbNode, (node as BreakOrContinueStatement).label); - case SyntaxKind.ReturnStatement: - return visitNode(cbNode, (node as ReturnStatement).expression); - case SyntaxKind.WithStatement: - return visitNode(cbNode, (node as WithStatement).expression) || - visitNode(cbNode, (node as WithStatement).statement); - case SyntaxKind.SwitchStatement: - return visitNode(cbNode, (node as SwitchStatement).expression) || - visitNode(cbNode, (node as SwitchStatement).caseBlock); - case SyntaxKind.CaseBlock: - return visitNodes(cbNode, cbNodes, (node as CaseBlock).clauses); - case SyntaxKind.CaseClause: - return visitNode(cbNode, (node as CaseClause).expression) || - visitNodes(cbNode, cbNodes, (node as CaseClause).statements); - case SyntaxKind.DefaultClause: - return visitNodes(cbNode, cbNodes, (node as DefaultClause).statements); - case SyntaxKind.LabeledStatement: - return visitNode(cbNode, (node as LabeledStatement).label) || - visitNode(cbNode, (node as LabeledStatement).statement); - case SyntaxKind.ThrowStatement: - return visitNode(cbNode, (node as ThrowStatement).expression); - case SyntaxKind.TryStatement: - return visitNode(cbNode, (node as TryStatement).tryBlock) || - visitNode(cbNode, (node as TryStatement).catchClause) || - visitNode(cbNode, (node as TryStatement).finallyBlock); - case SyntaxKind.CatchClause: - return visitNode(cbNode, (node as CatchClause).variableDeclaration) || - visitNode(cbNode, (node as CatchClause).block); - case SyntaxKind.Decorator: - return visitNode(cbNode, (node as Decorator).expression); - case SyntaxKind.ClassDeclaration: - case SyntaxKind.ClassExpression: - return visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).modifiers) || - visitNode(cbNode, (node as ClassLikeDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).heritageClauses) || - visitNodes(cbNode, cbNodes, (node as ClassLikeDeclaration).members); - case SyntaxKind.InterfaceDeclaration: - return visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).modifiers) || - visitNode(cbNode, (node as InterfaceDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).typeParameters) || - visitNodes(cbNode, cbNodes, (node as ClassDeclaration).heritageClauses) || - visitNodes(cbNode, cbNodes, (node as InterfaceDeclaration).members); - case SyntaxKind.TypeAliasDeclaration: - return visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).modifiers) || - visitNode(cbNode, (node as TypeAliasDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as TypeAliasDeclaration).typeParameters) || - visitNode(cbNode, (node as TypeAliasDeclaration).type); - case SyntaxKind.EnumDeclaration: - return visitNodes(cbNode, cbNodes, (node as EnumDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as EnumDeclaration).modifiers) || - visitNode(cbNode, (node as EnumDeclaration).name) || - visitNodes(cbNode, cbNodes, (node as EnumDeclaration).members); - case SyntaxKind.EnumMember: - return visitNode(cbNode, (node as EnumMember).name) || - visitNode(cbNode, (node as EnumMember).initializer); - case SyntaxKind.ModuleDeclaration: - return visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as ModuleDeclaration).modifiers) || - visitNode(cbNode, (node as ModuleDeclaration).name) || - visitNode(cbNode, (node as ModuleDeclaration).body); - case SyntaxKind.ImportEqualsDeclaration: - return visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as ImportEqualsDeclaration).modifiers) || - visitNode(cbNode, (node as ImportEqualsDeclaration).name) || - visitNode(cbNode, (node as ImportEqualsDeclaration).moduleReference); - case SyntaxKind.ImportDeclaration: - return visitNodes(cbNode, cbNodes, (node as ImportDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as ImportDeclaration).modifiers) || - visitNode(cbNode, (node as ImportDeclaration).importClause) || - visitNode(cbNode, (node as ImportDeclaration).moduleSpecifier) || - visitNode(cbNode, (node as ImportDeclaration).assertClause); - case SyntaxKind.ImportClause: - return visitNode(cbNode, (node as ImportClause).name) || - visitNode(cbNode, (node as ImportClause).namedBindings); - case SyntaxKind.AssertClause: - return visitNodes(cbNode, cbNodes, (node as AssertClause).elements); - case SyntaxKind.AssertEntry: - return visitNode(cbNode, (node as AssertEntry).name) || - visitNode(cbNode, (node as AssertEntry).value); - case SyntaxKind.NamespaceExportDeclaration: - return visitNodes(cbNode, cbNodes, (node as NamespaceExportDeclaration).decorators) || - visitNode(cbNode, (node as NamespaceExportDeclaration).name); - case SyntaxKind.NamespaceImport: - return visitNode(cbNode, (node as NamespaceImport).name); - case SyntaxKind.NamespaceExport: - return visitNode(cbNode, (node as NamespaceExport).name); - case SyntaxKind.NamedImports: - case SyntaxKind.NamedExports: - return visitNodes(cbNode, cbNodes, (node as NamedImportsOrExports).elements); - case SyntaxKind.ExportDeclaration: - return visitNodes(cbNode, cbNodes, (node as ExportDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as ExportDeclaration).modifiers) || - visitNode(cbNode, (node as ExportDeclaration).exportClause) || - visitNode(cbNode, (node as ExportDeclaration).moduleSpecifier) || - visitNode(cbNode, (node as ExportDeclaration).assertClause); - case SyntaxKind.ImportSpecifier: - case SyntaxKind.ExportSpecifier: - return visitNode(cbNode, (node as ImportOrExportSpecifier).propertyName) || - visitNode(cbNode, (node as ImportOrExportSpecifier).name); - case SyntaxKind.ExportAssignment: - return visitNodes(cbNode, cbNodes, (node as ExportAssignment).decorators) || - visitNodes(cbNode, cbNodes, (node as ExportAssignment).modifiers) || - visitNode(cbNode, (node as ExportAssignment).expression); - case SyntaxKind.TemplateExpression: - return visitNode(cbNode, (node as TemplateExpression).head) || - visitNodes(cbNode, cbNodes, (node as TemplateExpression).templateSpans); - case SyntaxKind.TemplateSpan: - return visitNode(cbNode, (node as TemplateSpan).expression) || - visitNode(cbNode, (node as TemplateSpan).literal); - case SyntaxKind.TemplateLiteralType: - return visitNode(cbNode, (node as TemplateLiteralTypeNode).head) || - visitNodes(cbNode, cbNodes, (node as TemplateLiteralTypeNode).templateSpans); - case SyntaxKind.TemplateLiteralTypeSpan: - return visitNode(cbNode, (node as TemplateLiteralTypeSpan).type) || - visitNode(cbNode, (node as TemplateLiteralTypeSpan).literal); - case SyntaxKind.ComputedPropertyName: - return visitNode(cbNode, (node as ComputedPropertyName).expression); - case SyntaxKind.HeritageClause: - return visitNodes(cbNode, cbNodes, (node as HeritageClause).types); - case SyntaxKind.ExpressionWithTypeArguments: - return visitNode(cbNode, (node as ExpressionWithTypeArguments).expression) || - visitNodes(cbNode, cbNodes, (node as ExpressionWithTypeArguments).typeArguments); - case SyntaxKind.ExternalModuleReference: - return visitNode(cbNode, (node as ExternalModuleReference).expression); - case SyntaxKind.MissingDeclaration: - return visitNodes(cbNode, cbNodes, (node as MissingDeclaration).decorators) || - visitNodes(cbNode, cbNodes, (node as MissingDeclaration).modifiers); - case SyntaxKind.CommaListExpression: - return visitNodes(cbNode, cbNodes, (node as CommaListExpression).elements); - - case SyntaxKind.JsxElement: - return visitNode(cbNode, (node as JsxElement).openingElement) || - visitNodes(cbNode, cbNodes, (node as JsxElement).children) || - visitNode(cbNode, (node as JsxElement).closingElement); - case SyntaxKind.JsxFragment: - return visitNode(cbNode, (node as JsxFragment).openingFragment) || - visitNodes(cbNode, cbNodes, (node as JsxFragment).children) || - visitNode(cbNode, (node as JsxFragment).closingFragment); - case SyntaxKind.JsxSelfClosingElement: - case SyntaxKind.JsxOpeningElement: - return visitNode(cbNode, (node as JsxOpeningLikeElement).tagName) || - visitNodes(cbNode, cbNodes, (node as JsxOpeningLikeElement).typeArguments) || - visitNode(cbNode, (node as JsxOpeningLikeElement).attributes); - case SyntaxKind.JsxAttributes: - return visitNodes(cbNode, cbNodes, (node as JsxAttributes).properties); - case SyntaxKind.JsxAttribute: - return visitNode(cbNode, (node as JsxAttribute).name) || - visitNode(cbNode, (node as JsxAttribute).initializer); - case SyntaxKind.JsxSpreadAttribute: - return visitNode(cbNode, (node as JsxSpreadAttribute).expression); - case SyntaxKind.JsxExpression: - return visitNode(cbNode, (node as JsxExpression).dotDotDotToken) || - visitNode(cbNode, (node as JsxExpression).expression); - case SyntaxKind.JsxClosingElement: - return visitNode(cbNode, (node as JsxClosingElement).tagName); - - case SyntaxKind.OptionalType: - case SyntaxKind.RestType: - case SyntaxKind.JSDocTypeExpression: - case SyntaxKind.JSDocNonNullableType: - case SyntaxKind.JSDocNullableType: - case SyntaxKind.JSDocOptionalType: - case SyntaxKind.JSDocVariadicType: - return visitNode(cbNode, (node as OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode).type); - case SyntaxKind.JSDocFunctionType: - return visitNodes(cbNode, cbNodes, (node as JSDocFunctionType).parameters) || - visitNode(cbNode, (node as JSDocFunctionType).type); - case SyntaxKind.JSDoc: - return (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)) - || visitNodes(cbNode, cbNodes, (node as JSDoc).tags); - case SyntaxKind.JSDocSeeTag: - return visitNode(cbNode, (node as JSDocSeeTag).tagName) || - visitNode(cbNode, (node as JSDocSeeTag).name) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocNameReference: - return visitNode(cbNode, (node as JSDocNameReference).name); - case SyntaxKind.JSDocMemberName: - return visitNode(cbNode, (node as JSDocMemberName).left) || - visitNode(cbNode, (node as JSDocMemberName).right); - case SyntaxKind.JSDocParameterTag: - case SyntaxKind.JSDocPropertyTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - ((node as JSDocPropertyLikeTag).isNameFirst - ? visitNode(cbNode, (node as JSDocPropertyLikeTag).name) || - visitNode(cbNode, (node as JSDocPropertyLikeTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)) - : visitNode(cbNode, (node as JSDocPropertyLikeTag).typeExpression) || - visitNode(cbNode, (node as JSDocPropertyLikeTag).name) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined))); - case SyntaxKind.JSDocAuthorTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocImplementsTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocImplementsTag).class) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocAugmentsTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocAugmentsTag).class) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocTemplateTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocTemplateTag).constraint) || - visitNodes(cbNode, cbNodes, (node as JSDocTemplateTag).typeParameters) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocTypedefTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - ((node as JSDocTypedefTag).typeExpression && - (node as JSDocTypedefTag).typeExpression!.kind === SyntaxKind.JSDocTypeExpression - ? visitNode(cbNode, (node as JSDocTypedefTag).typeExpression) || - visitNode(cbNode, (node as JSDocTypedefTag).fullName) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)) - : visitNode(cbNode, (node as JSDocTypedefTag).fullName) || - visitNode(cbNode, (node as JSDocTypedefTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined))); - case SyntaxKind.JSDocCallbackTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocCallbackTag).fullName) || - visitNode(cbNode, (node as JSDocCallbackTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocReturnTag: - case SyntaxKind.JSDocTypeTag: - case SyntaxKind.JSDocThisTag: - case SyntaxKind.JSDocEnumTag: - return visitNode(cbNode, (node as JSDocTag).tagName) || - visitNode(cbNode, (node as JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag).typeExpression) || - (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.JSDocSignature: - return forEach((node as JSDocSignature).typeParameters, cbNode) || - forEach((node as JSDocSignature).parameters, cbNode) || - visitNode(cbNode, (node as JSDocSignature).type); - case SyntaxKind.JSDocLink: - case SyntaxKind.JSDocLinkCode: - case SyntaxKind.JSDocLinkPlain: - return visitNode(cbNode, (node as JSDocLink | JSDocLinkCode | JSDocLinkPlain).name); - case SyntaxKind.JSDocTypeLiteral: - return forEach((node as JSDocTypeLiteral).jsDocPropertyTags, cbNode); - case SyntaxKind.JSDocTag: - case SyntaxKind.JSDocClassTag: - case SyntaxKind.JSDocPublicTag: - case SyntaxKind.JSDocPrivateTag: - case SyntaxKind.JSDocProtectedTag: - case SyntaxKind.JSDocReadonlyTag: - case SyntaxKind.JSDocDeprecatedTag: - return visitNode(cbNode, (node as JSDocTag).tagName) - || (typeof (node as JSDoc).comment === "string" ? undefined : visitNodes(cbNode, cbNodes, (node as JSDoc).comment as NodeArray | undefined)); - case SyntaxKind.PartiallyEmittedExpression: - return visitNode(cbNode, (node as PartiallyEmittedExpression).expression); - } + + return forEachChildTable[node.kind]?.(node, cbNode, cbNodes); } /** @internal */ From e42cfaf14cbf43979813f93526e2573a4274a24f Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 8 Aug 2022 21:34:07 +0000 Subject: [PATCH 2/9] Let's see if 'new' changes anything. --- src/compiler/parser.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 00d6502ae9b0d..188245fa7cca3 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -97,7 +97,7 @@ namespace ts { type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - const forEachChildTable = Array(SyntaxKind.Count); + const forEachChildTable = new Array(SyntaxKind.Count); forEachChildTable[SyntaxKind.QualifiedName] = forEachQualifiedName; From f8e1c2afaa8fdbeca54cb350f802d6cb4ee00c38 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 8 Aug 2022 22:47:25 +0000 Subject: [PATCH 3/9] Co-locate each assignment into `forEachChildTable`. --- src/compiler/parser.ts | 335 ++++++++++++++++++++--------------------- 1 file changed, 167 insertions(+), 168 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 188245fa7cca3..be298aaf050e6 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -98,14 +98,179 @@ namespace ts { type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; const forEachChildTable = new Array(SyntaxKind.Count); - forEachChildTable[SyntaxKind.QualifiedName] = forEachQualifiedName; + forEachChildTable[SyntaxKind.TypeParameter] = forEachTypeParameter; + forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachShorthandPropertyAssignment; + forEachChildTable[SyntaxKind.SpreadAssignment] = forEachSpreadAssignment; + forEachChildTable[SyntaxKind.Parameter] = forEachParameter; + forEachChildTable[SyntaxKind.PropertyDeclaration] = forEachPropertyDeclaration; + forEachChildTable[SyntaxKind.PropertySignature] = forEachPropertySignature; + forEachChildTable[SyntaxKind.PropertyAssignment] = forEachPropertyAssignment; + forEachChildTable[SyntaxKind.VariableDeclaration] = forEachVariableDeclaration; + forEachChildTable[SyntaxKind.BindingElement] = forEachBindingElement; + forEachChildTable[SyntaxKind.IndexSignature] = forEachIndexSignature; + forEachChildTable[SyntaxKind.ConstructorType] = forEachConstructorType; + forEachChildTable[SyntaxKind.FunctionType] = forEachFunctionType; + forEachChildTable[SyntaxKind.CallSignature] = forEachCallOrConstructSignature; + forEachChildTable[SyntaxKind.ConstructSignature] = forEachCallOrConstructSignature; + forEachChildTable[SyntaxKind.MethodDeclaration] = forEachMethodDeclaration; + forEachChildTable[SyntaxKind.MethodSignature] = forEachMethodSignature; + forEachChildTable[SyntaxKind.Constructor] = forEachConstructor; + forEachChildTable[SyntaxKind.GetAccessor] = forEachGetAccessor; + forEachChildTable[SyntaxKind.SetAccessor] = forEachSetAccessor; + forEachChildTable[SyntaxKind.FunctionDeclaration] = forEachFunctionDeclaration; + forEachChildTable[SyntaxKind.FunctionExpression] = forEachFunctionExpression; + forEachChildTable[SyntaxKind.ArrowFunction] = forEachArrowFunction; + forEachChildTable[SyntaxKind.ClassStaticBlockDeclaration] = forEachClassStaticBlockDeclaration; + forEachChildTable[SyntaxKind.TypeReference] = forEachTypeReference; + forEachChildTable[SyntaxKind.TypePredicate] = forEachTypePredicate; + forEachChildTable[SyntaxKind.TypeQuery] = forEachTypeQuery; + forEachChildTable[SyntaxKind.TypeLiteral] = forEachTypeLiteral; + forEachChildTable[SyntaxKind.ArrayType] = forEachArrayType; + forEachChildTable[SyntaxKind.TupleType] = forEachTupleType; + forEachChildTable[SyntaxKind.UnionType] = forEachUnionOrIntersectionType; + forEachChildTable[SyntaxKind.IntersectionType] = forEachUnionOrIntersectionType; + forEachChildTable[SyntaxKind.ConditionalType] = forEachConditionalType; + forEachChildTable[SyntaxKind.InferType] = forEachInferType; + forEachChildTable[SyntaxKind.ImportType] = forEachImportType; + forEachChildTable[SyntaxKind.ImportTypeAssertionContainer] = forEachImportTypeAssertionContainer; + forEachChildTable[SyntaxKind.ParenthesizedType] = forEachParenthesizedTypeOrTypeOperator; + forEachChildTable[SyntaxKind.TypeOperator] = forEachParenthesizedTypeOrTypeOperator; + forEachChildTable[SyntaxKind.IndexedAccessType] = forEachIndexedAccessType; + forEachChildTable[SyntaxKind.MappedType] = forEachMappedType; + forEachChildTable[SyntaxKind.LiteralType] = forEachLiteralType; + forEachChildTable[SyntaxKind.NamedTupleMember] = forEachNamedTupleMember; + forEachChildTable[SyntaxKind.ObjectBindingPattern] = forEachObjectOrArrayBindingPattern; + forEachChildTable[SyntaxKind.ArrayBindingPattern] = forEachObjectOrArrayBindingPattern; + forEachChildTable[SyntaxKind.ArrayLiteralExpression] = forEachArrayLiteralExpression; + forEachChildTable[SyntaxKind.ObjectLiteralExpression] = forEachObjectLiteralExpression; + forEachChildTable[SyntaxKind.PropertyAccessExpression] = forEachPropertyAccessExpression; + forEachChildTable[SyntaxKind.ElementAccessExpression] = forEachElementAccessExpression; + forEachChildTable[SyntaxKind.CallExpression] = forEachCallExpression; + forEachChildTable[SyntaxKind.NewExpression] = forEachCallExpression; + forEachChildTable[SyntaxKind.TaggedTemplateExpression] = forEachTaggedTemplateExpression; + forEachChildTable[SyntaxKind.TypeAssertionExpression] = forEachTypeAssertionExpression; + forEachChildTable[SyntaxKind.ParenthesizedExpression] = forEachParenthesizedExpression; + forEachChildTable[SyntaxKind.DeleteExpression] = forEachDeleteExpression; + forEachChildTable[SyntaxKind.TypeOfExpression] = forEachTypeOfExpression; + forEachChildTable[SyntaxKind.VoidExpression] = forEachVoidExpression; + forEachChildTable[SyntaxKind.PrefixUnaryExpression] = forEachPrefixUnaryExpression; + forEachChildTable[SyntaxKind.YieldExpression] = forEachYieldExpression; + forEachChildTable[SyntaxKind.AwaitExpression] = forEachAwaitExpression; + forEachChildTable[SyntaxKind.PostfixUnaryExpression] = forEachPostfixUnaryExpression; + forEachChildTable[SyntaxKind.BinaryExpression] = forEachBinaryExpression; + forEachChildTable[SyntaxKind.AsExpression] = forEachAsExpression; + forEachChildTable[SyntaxKind.NonNullExpression] = forEachNonNullExpression; + forEachChildTable[SyntaxKind.MetaProperty] = forEachMetaProperty; + forEachChildTable[SyntaxKind.ConditionalExpression] = forEachConditionalExpression; + forEachChildTable[SyntaxKind.SpreadElement] = forEachSpreadElement; + forEachChildTable[SyntaxKind.Block] = forEachBlock; + forEachChildTable[SyntaxKind.ModuleBlock] = forEachBlock; + forEachChildTable[SyntaxKind.SourceFile] = forEachSourceFile; + forEachChildTable[SyntaxKind.VariableStatement] = forEachVariableStatement; + forEachChildTable[SyntaxKind.VariableDeclarationList] = forEachVariableDeclarationList; + forEachChildTable[SyntaxKind.ExpressionStatement] = forEachExpressionStatement; + forEachChildTable[SyntaxKind.IfStatement] = forEachIfStatement; + forEachChildTable[SyntaxKind.DoStatement] = forEachDoStatement; + forEachChildTable[SyntaxKind.WhileStatement] = forEachWhileStatement; + forEachChildTable[SyntaxKind.ForStatement] = forEachForStatement; + forEachChildTable[SyntaxKind.ForInStatement] = forEachForInStatement; + forEachChildTable[SyntaxKind.ForOfStatement] = forEachForOfStatement; + forEachChildTable[SyntaxKind.ContinueStatement] = forEachContinueStatement; + forEachChildTable[SyntaxKind.BreakStatement] = forEachContinueStatement; + forEachChildTable[SyntaxKind.ReturnStatement] = forEachReturnStatement; + forEachChildTable[SyntaxKind.WithStatement] = forEachWithStatement; + forEachChildTable[SyntaxKind.SwitchStatement] = forEachSwitchStatement; + forEachChildTable[SyntaxKind.CaseBlock] = forEachCaseBlock; + forEachChildTable[SyntaxKind.CaseClause] = forEachCaseClause; + forEachChildTable[SyntaxKind.DefaultClause] = forEachDefaultClause; + forEachChildTable[SyntaxKind.LabeledStatement] = forEachLabeledStatement; + forEachChildTable[SyntaxKind.ThrowStatement] = forEachThrowStatement; + forEachChildTable[SyntaxKind.TryStatement] = forEachTryStatement; + forEachChildTable[SyntaxKind.CatchClause] = forEachCatchClause; + forEachChildTable[SyntaxKind.Decorator] = forEachDecorator; + forEachChildTable[SyntaxKind.ClassDeclaration] = forEachClassDeclarationOrExpression; + forEachChildTable[SyntaxKind.ClassExpression] = forEachClassDeclarationOrExpression; + forEachChildTable[SyntaxKind.InterfaceDeclaration] = forEachInterfaceDeclaration; + forEachChildTable[SyntaxKind.TypeAliasDeclaration] = forEachTypeAliasDeclaration; + forEachChildTable[SyntaxKind.EnumDeclaration] = forEachEnumDeclaration; + forEachChildTable[SyntaxKind.EnumMember] = forEachEnumMember; + forEachChildTable[SyntaxKind.ModuleDeclaration] = forEachModuleDeclaration; + forEachChildTable[SyntaxKind.ImportEqualsDeclaration] = forEachImportEqualsDeclaration; + forEachChildTable[SyntaxKind.ImportDeclaration] = forEachImportDeclaration; + forEachChildTable[SyntaxKind.ImportClause] = forEachImportClause; + forEachChildTable[SyntaxKind.AssertClause] = forEachAssertClause; + forEachChildTable[SyntaxKind.AssertEntry] = forEachAssertEntry; + forEachChildTable[SyntaxKind.NamespaceExportDeclaration] = forEachNamespaceExportDeclaration; + forEachChildTable[SyntaxKind.NamespaceImport] = forEachNamespaceImport; + forEachChildTable[SyntaxKind.NamespaceExport] = forEachNamespaceExport; + forEachChildTable[SyntaxKind.NamedImports] = forEachNamedImportsOrExports; + forEachChildTable[SyntaxKind.NamedExports] = forEachNamedImportsOrExports; + forEachChildTable[SyntaxKind.ExportDeclaration] = forEachExportDeclaration; + forEachChildTable[SyntaxKind.ImportSpecifier] = forEachImportOrExportSpecifier; + forEachChildTable[SyntaxKind.ExportSpecifier] = forEachImportOrExportSpecifier; + forEachChildTable[SyntaxKind.ExportAssignment] = forEachExportAssignment; + forEachChildTable[SyntaxKind.TemplateExpression] = forEachTemplateExpression; + forEachChildTable[SyntaxKind.TemplateSpan] = forEachTemplateSpan; + forEachChildTable[SyntaxKind.TemplateLiteralType] = forEachTemplateLiteralType; + forEachChildTable[SyntaxKind.TemplateLiteralTypeSpan] = forEachTemplateLiteralTypeSpan; + forEachChildTable[SyntaxKind.ComputedPropertyName] = forEachComputedPropertyName; + forEachChildTable[SyntaxKind.HeritageClause] = forEachHeritageClause; + forEachChildTable[SyntaxKind.ExpressionWithTypeArguments] = forEachExpressionWithTypeArguments; + forEachChildTable[SyntaxKind.ExternalModuleReference] = forEachExternalModuleReference; + forEachChildTable[SyntaxKind.MissingDeclaration] = forEachMissingDeclaration; + forEachChildTable[SyntaxKind.CommaListExpression] = forEachCommaListExpression; + forEachChildTable[SyntaxKind.JsxElement] = forEachJsxElement; + forEachChildTable[SyntaxKind.JsxFragment] = forEachJsxFragment; + forEachChildTable[SyntaxKind.JsxSelfClosingElement] = forEachJsxOpeningOrSelfClosingElement; + forEachChildTable[SyntaxKind.JsxOpeningElement] = forEachJsxOpeningOrSelfClosingElement; + forEachChildTable[SyntaxKind.JsxAttributes] = forEachJsxAttributes; + forEachChildTable[SyntaxKind.JsxAttribute] = forEachJsxAttribute; + forEachChildTable[SyntaxKind.JsxSpreadAttribute] = forEachJsxSpreadAttribute; + forEachChildTable[SyntaxKind.JsxExpression] = forEachJsxExpression; + forEachChildTable[SyntaxKind.JsxClosingElement] = forEachJsxClosingElement; + forEachChildTable[SyntaxKind.OptionalType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.RestType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocTypeExpression] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocNonNullableType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocNullableType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocOptionalType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocVariadicType] = forEachOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocFunctionType] = forEachJSDocFunctionType; + forEachChildTable[SyntaxKind.JSDoc] = forEachJSDoc; + forEachChildTable[SyntaxKind.JSDocSeeTag] = forEachJSDocSeeTag; + forEachChildTable[SyntaxKind.JSDocNameReference] = forEachJSDocNameReference; + forEachChildTable[SyntaxKind.JSDocMemberName] = forEachJSDocMemberName; + forEachChildTable[SyntaxKind.JSDocParameterTag] = forEachJSDocParameterOrPropertyTag; + forEachChildTable[SyntaxKind.JSDocPropertyTag] = forEachJSDocParameterOrPropertyTag; + forEachChildTable[SyntaxKind.JSDocAuthorTag] = forEachJSDocAuthorTag; + forEachChildTable[SyntaxKind.JSDocImplementsTag] = forEachJSDocImplementsTag; + forEachChildTable[SyntaxKind.JSDocAugmentsTag] = forEachJSDocAugmentsTag; + forEachChildTable[SyntaxKind.JSDocTemplateTag] = forEachJSDocTemplateTag; + forEachChildTable[SyntaxKind.JSDocTypedefTag] = forEachJSDocTypedefTag; + forEachChildTable[SyntaxKind.JSDocCallbackTag] = forEachJSDocCallbackTag; + forEachChildTable[SyntaxKind.JSDocReturnTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocTypeTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocThisTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocEnumTag] = forEachJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocSignature] = forEachJSDocSignature; + forEachChildTable[SyntaxKind.JSDocLink] = forEachJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocLinkCode] = forEachJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocLinkPlain] = forEachJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocTypeLiteral] = forEachJSDocTypeLiteral; + forEachChildTable[SyntaxKind.JSDocTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocClassTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocPublicTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocPrivateTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocProtectedTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocReadonlyTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.JSDocDeprecatedTag] = forEachJSDocTag; + forEachChildTable[SyntaxKind.PartiallyEmittedExpression] = forEachPartiallyEmittedExpression; function forEachQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); } - forEachChildTable[SyntaxKind.TypeParameter] = forEachTypeParameter; function forEachTypeParameter(node: TypeParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -114,7 +279,6 @@ namespace ts { visitNode(cbNode, node.default) || visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachShorthandPropertyAssignment; function forEachShorthandPropertyAssignment(node: ShorthandPropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -125,12 +289,10 @@ namespace ts { visitNode(cbNode, node.equalsToken) || visitNode(cbNode, node.objectAssignmentInitializer); } - forEachChildTable[SyntaxKind.SpreadAssignment] = forEachSpreadAssignment; function forEachSpreadAssignment(node: SpreadAssignment, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.Parameter] = forEachParameter; function forEachParameter(node: ParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -140,7 +302,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.PropertyDeclaration] = forEachPropertyDeclaration; function forEachPropertyDeclaration(node: PropertyDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -150,7 +311,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.PropertySignature] = forEachPropertySignature; function forEachPropertySignature(node: PropertySignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -159,7 +319,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.PropertyAssignment] = forEachPropertyAssignment; function forEachPropertyAssignment(node: PropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -169,7 +328,6 @@ namespace ts { visitNode(cbNode, node.exclamationToken) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.VariableDeclaration] = forEachVariableDeclaration; function forEachVariableDeclaration(node: VariableDeclaration, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name) || @@ -177,7 +335,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.BindingElement] = forEachBindingElement; function forEachBindingElement(node: BindingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.dotDotDotToken) || @@ -185,7 +342,6 @@ namespace ts { visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.IndexSignature] = forEachIndexSignature; function forEachIndexSignature(node: IndexSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -194,14 +350,12 @@ namespace ts { visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.ConstructorType] = forEachConstructorType; function forEachConstructorType(node: ConstructorTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.FunctionType] = forEachFunctionType; function forEachFunctionType(node: FunctionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -209,15 +363,12 @@ namespace ts { visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.CallSignature] = forEachCallOrConstructSignature; - forEachChildTable[SyntaxKind.ConstructSignature] = forEachCallOrConstructSignature; function forEachCallOrConstructSignature(node: CallSignatureDeclaration | ConstructSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.MethodDeclaration] = forEachMethodDeclaration; function forEachMethodDeclaration(node: MethodDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -230,7 +381,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.MethodSignature] = forEachMethodSignature; function forEachMethodSignature(node: MethodSignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -240,7 +390,6 @@ namespace ts { visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.Constructor] = forEachConstructor; function forEachConstructor(node: ConstructorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -251,7 +400,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.GetAccessor] = forEachGetAccessor; function forEachGetAccessor(node: GetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -261,7 +409,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.SetAccessor] = forEachSetAccessor; function forEachSetAccessor(node: SetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -271,7 +418,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.FunctionDeclaration] = forEachFunctionDeclaration; function forEachFunctionDeclaration(node: FunctionDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -283,7 +429,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.FunctionExpression] = forEachFunctionExpression; function forEachFunctionExpression(node: FunctionExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -294,7 +439,6 @@ namespace ts { visitNode(cbNode, node.type) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.ArrowFunction] = forEachArrowFunction; function forEachArrowFunction(node: ArrowFunction, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -304,54 +448,44 @@ namespace ts { visitNode(cbNode, node.equalsGreaterThanToken) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.ClassStaticBlockDeclaration] = forEachClassStaticBlockDeclaration; function forEachClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.TypeReference] = forEachTypeReference; function forEachTypeReference(node: TypeReferenceNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.typeName) || visitNodes(cbNode, cbNodes, node.typeArguments); } - forEachChildTable[SyntaxKind.TypePredicate] = forEachTypePredicate; function forEachTypePredicate(node: TypePredicateNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.assertsModifier) || visitNode(cbNode, node.parameterName) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.TypeQuery] = forEachTypeQuery; function forEachTypeQuery(node: TypeQueryNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.exprName) || visitNodes(cbNode, cbNodes, node.typeArguments); } - forEachChildTable[SyntaxKind.TypeLiteral] = forEachTypeLiteral; function forEachTypeLiteral(node: TypeLiteralNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.members); } - forEachChildTable[SyntaxKind.ArrayType] = forEachArrayType; function forEachArrayType(node: ArrayTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.elementType); } - forEachChildTable[SyntaxKind.TupleType] = forEachTupleType; function forEachTupleType(node: TupleTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.elements); } - forEachChildTable[SyntaxKind.UnionType] = forEachUnionOrIntersectionType; - forEachChildTable[SyntaxKind.IntersectionType] = forEachUnionOrIntersectionType; function forEachUnionOrIntersectionType(node: UnionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.types); } - forEachChildTable[SyntaxKind.ConditionalType] = forEachConditionalType; function forEachConditionalType(node: ConditionalTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.checkType) || @@ -359,12 +493,10 @@ namespace ts { visitNode(cbNode, node.trueType) || visitNode(cbNode, node.falseType); } - forEachChildTable[SyntaxKind.InferType] = forEachInferType; function forEachInferType(node: InferTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.typeParameter); } - forEachChildTable[SyntaxKind.ImportType] = forEachImportType; function forEachImportType(node: ImportTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.argument) || @@ -372,24 +504,19 @@ namespace ts { visitNode(cbNode, node.qualifier) || visitNodes(cbNode, cbNodes, node.typeArguments); } - forEachChildTable[SyntaxKind.ImportTypeAssertionContainer] = forEachImportTypeAssertionContainer; function forEachImportTypeAssertionContainer(node: ImportTypeAssertionContainer, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.assertClause); } - forEachChildTable[SyntaxKind.ParenthesizedType] = forEachParenthesizedTypeOrTypeOperator; - forEachChildTable[SyntaxKind.TypeOperator] = forEachParenthesizedTypeOrTypeOperator; function forEachParenthesizedTypeOrTypeOperator(node: ParenthesizedTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, (node as ParenthesizedTypeNode | TypeOperatorNode).type); } - forEachChildTable[SyntaxKind.IndexedAccessType] = forEachIndexedAccessType; function forEachIndexedAccessType(node: IndexedAccessTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.objectType) || visitNode(cbNode, node.indexType); } - forEachChildTable[SyntaxKind.MappedType] = forEachMappedType; function forEachMappedType(node: MappedTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.readonlyToken) || @@ -399,12 +526,10 @@ namespace ts { visitNode(cbNode, node.type) || visitNodes(cbNode, cbNodes, node.members); } - forEachChildTable[SyntaxKind.LiteralType] = forEachLiteralType; function forEachLiteralType(node: LiteralTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.literal); } - forEachChildTable[SyntaxKind.NamedTupleMember] = forEachNamedTupleMember; function forEachNamedTupleMember(node: NamedTupleMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.dotDotDotToken) || @@ -412,38 +537,30 @@ namespace ts { visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.ObjectBindingPattern] = forEachObjectOrArrayBindingPattern; - forEachChildTable[SyntaxKind.ArrayBindingPattern] = forEachObjectOrArrayBindingPattern; function forEachObjectOrArrayBindingPattern(node: ObjectBindingPattern, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.elements); } - forEachChildTable[SyntaxKind.ArrayLiteralExpression] = forEachArrayLiteralExpression; function forEachArrayLiteralExpression(node: ArrayLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.elements); } - forEachChildTable[SyntaxKind.ObjectLiteralExpression] = forEachObjectLiteralExpression; function forEachObjectLiteralExpression(node: ObjectLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.properties); } - forEachChildTable[SyntaxKind.PropertyAccessExpression] = forEachPropertyAccessExpression; function forEachPropertyAccessExpression(node: PropertyAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.questionDotToken) || visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.ElementAccessExpression] = forEachElementAccessExpression; function forEachElementAccessExpression(node: ElementAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.questionDotToken) || visitNode(cbNode, node.argumentExpression); } - forEachChildTable[SyntaxKind.CallExpression] = forEachCallExpression; - forEachChildTable[SyntaxKind.NewExpression] = forEachCallExpression; function forEachCallExpression(node: CallExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || @@ -451,7 +568,6 @@ namespace ts { visitNodes(cbNode, cbNodes, node.typeArguments) || visitNodes(cbNode, cbNodes, node.arguments); } - forEachChildTable[SyntaxKind.TaggedTemplateExpression] = forEachTaggedTemplateExpression; function forEachTaggedTemplateExpression(node: TaggedTemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tag) || @@ -459,77 +575,63 @@ namespace ts { visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode(cbNode, node.template); } - forEachChildTable[SyntaxKind.TypeAssertionExpression] = forEachTypeAssertionExpression; function forEachTypeAssertionExpression(node: TypeAssertion, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.ParenthesizedExpression] = forEachParenthesizedExpression; function forEachParenthesizedExpression(node: ParenthesizedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.DeleteExpression] = forEachDeleteExpression; function forEachDeleteExpression(node: DeleteExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.TypeOfExpression] = forEachTypeOfExpression; function forEachTypeOfExpression(node: TypeOfExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.VoidExpression] = forEachVoidExpression; function forEachVoidExpression(node: VoidExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.PrefixUnaryExpression] = forEachPrefixUnaryExpression; function forEachPrefixUnaryExpression(node: PrefixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.operand); } - forEachChildTable[SyntaxKind.YieldExpression] = forEachYieldExpression; function forEachYieldExpression(node: YieldExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.AwaitExpression] = forEachAwaitExpression; function forEachAwaitExpression(node: AwaitExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.PostfixUnaryExpression] = forEachPostfixUnaryExpression; function forEachPostfixUnaryExpression(node: PostfixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.operand); } - forEachChildTable[SyntaxKind.BinaryExpression] = forEachBinaryExpression; function forEachBinaryExpression(node: BinaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); } - forEachChildTable[SyntaxKind.AsExpression] = forEachAsExpression; function forEachAsExpression(node: AsExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.NonNullExpression] = forEachNonNullExpression; function forEachNonNullExpression(node: NonNullExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.MetaProperty] = forEachMetaProperty; function forEachMetaProperty(node: MetaProperty, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.ConditionalExpression] = forEachConditionalExpression; function forEachConditionalExpression(node: ConditionalExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.condition) || @@ -538,60 +640,49 @@ namespace ts { visitNode(cbNode, node.colonToken) || visitNode(cbNode, node.whenFalse); } - forEachChildTable[SyntaxKind.SpreadElement] = forEachSpreadElement; function forEachSpreadElement(node: SpreadElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.Block] = forEachBlock; - forEachChildTable[SyntaxKind.ModuleBlock] = forEachBlock; function forEachBlock(node: Block, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.statements); } - forEachChildTable[SyntaxKind.SourceFile] = forEachSourceFile; function forEachSourceFile(node: SourceFile, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); } - forEachChildTable[SyntaxKind.VariableStatement] = forEachVariableStatement; function forEachVariableStatement(node: VariableStatement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); } - forEachChildTable[SyntaxKind.VariableDeclarationList] = forEachVariableDeclarationList; function forEachVariableDeclarationList(node: VariableDeclarationList, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.declarations); } - forEachChildTable[SyntaxKind.ExpressionStatement] = forEachExpressionStatement; function forEachExpressionStatement(node: ExpressionStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.IfStatement] = forEachIfStatement; function forEachIfStatement(node: IfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); } - forEachChildTable[SyntaxKind.DoStatement] = forEachDoStatement; function forEachDoStatement(node: DoStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.WhileStatement] = forEachWhileStatement; function forEachWhileStatement(node: WhileStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - forEachChildTable[SyntaxKind.ForStatement] = forEachForStatement; function forEachForStatement(node: ForStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.initializer) || @@ -599,14 +690,12 @@ namespace ts { visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); } - forEachChildTable[SyntaxKind.ForInStatement] = forEachForInStatement; function forEachForInStatement(node: ForInStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - forEachChildTable[SyntaxKind.ForOfStatement] = forEachForOfStatement; function forEachForOfStatement(node: ForOfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.awaitModifier) || @@ -614,76 +703,61 @@ namespace ts { visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - forEachChildTable[SyntaxKind.ContinueStatement] = forEachContinueStatement; - forEachChildTable[SyntaxKind.BreakStatement] = forEachContinueStatement; function forEachContinueStatement(node: ContinueStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.label); } - forEachChildTable[SyntaxKind.ReturnStatement] = forEachReturnStatement; function forEachReturnStatement(node: ReturnStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.WithStatement] = forEachWithStatement; function forEachWithStatement(node: WithStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - forEachChildTable[SyntaxKind.SwitchStatement] = forEachSwitchStatement; function forEachSwitchStatement(node: SwitchStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.caseBlock); } - forEachChildTable[SyntaxKind.CaseBlock] = forEachCaseBlock; function forEachCaseBlock(node: CaseBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.clauses); } - forEachChildTable[SyntaxKind.CaseClause] = forEachCaseClause; function forEachCaseClause(node: CaseClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.statements); } - forEachChildTable[SyntaxKind.DefaultClause] = forEachDefaultClause; function forEachDefaultClause(node: DefaultClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.statements); } - forEachChildTable[SyntaxKind.LabeledStatement] = forEachLabeledStatement; function forEachLabeledStatement(node: LabeledStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); } - forEachChildTable[SyntaxKind.ThrowStatement] = forEachThrowStatement; function forEachThrowStatement(node: ThrowStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.TryStatement] = forEachTryStatement; function forEachTryStatement(node: TryStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); } - forEachChildTable[SyntaxKind.CatchClause] = forEachCatchClause; function forEachCatchClause(node: CatchClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); } - forEachChildTable[SyntaxKind.Decorator] = forEachDecorator; function forEachDecorator(node: Decorator, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.ClassDeclaration] = forEachClassDeclarationOrExpression; - forEachChildTable[SyntaxKind.ClassExpression] = forEachClassDeclarationOrExpression; function forEachClassDeclarationOrExpression(node: ClassDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.modifiers) || @@ -692,7 +766,6 @@ namespace ts { visitNodes(cbNode, cbNodes, node.heritageClauses) || visitNodes(cbNode, cbNodes, node.members); } - forEachChildTable[SyntaxKind.InterfaceDeclaration] = forEachInterfaceDeclaration; function forEachInterfaceDeclaration(node: InterfaceDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -702,7 +775,6 @@ namespace ts { visitNodes(cbNode, cbNodes, node.heritageClauses) || visitNodes(cbNode, cbNodes, node.members); } - forEachChildTable[SyntaxKind.TypeAliasDeclaration] = forEachTypeAliasDeclaration; function forEachTypeAliasDeclaration(node: TypeAliasDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -711,7 +783,6 @@ namespace ts { visitNodes(cbNode, cbNodes, node.typeParameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.EnumDeclaration] = forEachEnumDeclaration; function forEachEnumDeclaration(node: EnumDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -719,13 +790,11 @@ namespace ts { visitNode(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.members); } - forEachChildTable[SyntaxKind.EnumMember] = forEachEnumMember; function forEachEnumMember(node: EnumMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.ModuleDeclaration] = forEachModuleDeclaration; function forEachModuleDeclaration(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -733,7 +802,6 @@ namespace ts { visitNode(cbNode, node.name) || visitNode(cbNode, node.body); } - forEachChildTable[SyntaxKind.ImportEqualsDeclaration] = forEachImportEqualsDeclaration; function forEachImportEqualsDeclaration(node: ImportEqualsDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -741,7 +809,6 @@ namespace ts { visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); } - forEachChildTable[SyntaxKind.ImportDeclaration] = forEachImportDeclaration; function forEachImportDeclaration(node: ImportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -750,46 +817,37 @@ namespace ts { visitNode(cbNode, node.moduleSpecifier) || visitNode(cbNode, node.assertClause); } - forEachChildTable[SyntaxKind.ImportClause] = forEachImportClause; function forEachImportClause(node: ImportClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); } - forEachChildTable[SyntaxKind.AssertClause] = forEachAssertClause; function forEachAssertClause(node: AssertClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.elements); } - forEachChildTable[SyntaxKind.AssertEntry] = forEachAssertEntry; function forEachAssertEntry(node: AssertEntry, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name) || visitNode(cbNode, node.value); } - forEachChildTable[SyntaxKind.NamespaceExportDeclaration] = forEachNamespaceExportDeclaration; function forEachNamespaceExportDeclaration(node: NamespaceExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.NamespaceImport] = forEachNamespaceImport; function forEachNamespaceImport(node: NamespaceImport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.NamespaceExport] = forEachNamespaceExport; function forEachNamespaceExport(node: NamespaceExport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.NamedImports] = forEachNamedImportsOrExports; - forEachChildTable[SyntaxKind.NamedExports] = forEachNamedImportsOrExports; function forEachNamedImportsOrExports(node: NamedImports, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.elements); } - forEachChildTable[SyntaxKind.ExportDeclaration] = forEachExportDeclaration; function forEachExportDeclaration(node: ExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || @@ -798,170 +856,134 @@ namespace ts { visitNode(cbNode, node.moduleSpecifier) || visitNode(cbNode, node.assertClause); } - forEachChildTable[SyntaxKind.ImportSpecifier] = forEachImportOrExportSpecifier; - forEachChildTable[SyntaxKind.ExportSpecifier] = forEachImportOrExportSpecifier; function forEachImportOrExportSpecifier(node: ImportSpecifier, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.ExportAssignment] = forEachExportAssignment; function forEachExportAssignment(node: ExportAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.TemplateExpression] = forEachTemplateExpression; function forEachTemplateExpression(node: TemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans); } - forEachChildTable[SyntaxKind.TemplateSpan] = forEachTemplateSpan; function forEachTemplateSpan(node: TemplateSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); } - forEachChildTable[SyntaxKind.TemplateLiteralType] = forEachTemplateLiteralType; function forEachTemplateLiteralType(node: TemplateLiteralTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans); } - forEachChildTable[SyntaxKind.TemplateLiteralTypeSpan] = forEachTemplateLiteralTypeSpan; function forEachTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.type) || visitNode(cbNode, node.literal); } - forEachChildTable[SyntaxKind.ComputedPropertyName] = forEachComputedPropertyName; function forEachComputedPropertyName(node: ComputedPropertyName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.HeritageClause] = forEachHeritageClause; function forEachHeritageClause(node: HeritageClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.types); } - forEachChildTable[SyntaxKind.ExpressionWithTypeArguments] = forEachExpressionWithTypeArguments; function forEachExpressionWithTypeArguments(node: ExpressionWithTypeArguments, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.typeArguments); } - forEachChildTable[SyntaxKind.ExternalModuleReference] = forEachExternalModuleReference; function forEachExternalModuleReference(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.MissingDeclaration] = forEachMissingDeclaration; function forEachMissingDeclaration(node: MissingDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers); } - forEachChildTable[SyntaxKind.CommaListExpression] = forEachCommaListExpression; function forEachCommaListExpression(node: CommaListExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.elements); } - forEachChildTable[SyntaxKind.JsxElement] = forEachJsxElement; function forEachJsxElement(node: JsxElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.openingElement) || visitNodes(cbNode, cbNodes, node.children) || visitNode(cbNode, node.closingElement); } - forEachChildTable[SyntaxKind.JsxFragment] = forEachJsxFragment; function forEachJsxFragment(node: JsxFragment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.openingFragment) || visitNodes(cbNode, cbNodes, node.children) || visitNode(cbNode, node.closingFragment); } - forEachChildTable[SyntaxKind.JsxSelfClosingElement] = forEachJsxOpeningOrSelfClosingElement; - forEachChildTable[SyntaxKind.JsxOpeningElement] = forEachJsxOpeningOrSelfClosingElement; function forEachJsxOpeningOrSelfClosingElement(node: JsxOpeningLikeElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode(cbNode, node.attributes); } - forEachChildTable[SyntaxKind.JsxAttributes] = forEachJsxAttributes; function forEachJsxAttributes(node: JsxAttributes, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.properties); } - forEachChildTable[SyntaxKind.JsxAttribute] = forEachJsxAttribute; function forEachJsxAttribute(node: JsxAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); } - forEachChildTable[SyntaxKind.JsxSpreadAttribute] = forEachJsxSpreadAttribute; function forEachJsxSpreadAttribute(node: JsxSpreadAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.JsxExpression] = forEachJsxExpression; function forEachJsxExpression(node: JsxExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.expression); } - forEachChildTable[SyntaxKind.JsxClosingElement] = forEachJsxClosingElement; function forEachJsxClosingElement(node: JsxClosingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName); } - forEachChildTable[SyntaxKind.OptionalType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.RestType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocTypeExpression] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocNonNullableType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocNullableType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocOptionalType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocVariadicType] = forEachOptionalRestOrJSDocParameterModifier; function forEachOptionalRestOrJSDocParameterModifier(node: OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.JSDocFunctionType] = forEachJSDocFunctionType; function forEachJSDocFunctionType(node: JSDocFunctionType, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.JSDoc] = forEachJSDoc; function forEachJSDoc(node: JSDoc, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) || visitNodes(cbNode, cbNodes, node.tags); } - forEachChildTable[SyntaxKind.JSDocSeeTag] = forEachJSDocSeeTag; function forEachJSDocSeeTag(node: JSDocSeeTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.name) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocNameReference] = forEachJSDocNameReference; function forEachJSDocNameReference(node: JSDocNameReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.JSDocMemberName] = forEachJSDocMemberName; function forEachJSDocMemberName(node: JSDocMemberName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); } - forEachChildTable[SyntaxKind.JSDocParameterTag] = forEachJSDocParameterOrPropertyTag; - forEachChildTable[SyntaxKind.JSDocPropertyTag] = forEachJSDocParameterOrPropertyTag; function forEachJSDocParameterOrPropertyTag(node: JSDocParameterTag | JSDocPropertyTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || @@ -973,27 +995,23 @@ namespace ts { visitNode(cbNode, node.name) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); } - forEachChildTable[SyntaxKind.JSDocAuthorTag] = forEachJSDocAuthorTag; function forEachJSDocAuthorTag(node: JSDocAuthorTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocImplementsTag] = forEachJSDocImplementsTag; function forEachJSDocImplementsTag(node: JSDocImplementsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.class) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocAugmentsTag] = forEachJSDocAugmentsTag; function forEachJSDocAugmentsTag(node: JSDocAugmentsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.class) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocTemplateTag] = forEachJSDocTemplateTag; function forEachJSDocTemplateTag(node: JSDocTemplateTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || @@ -1001,7 +1019,6 @@ namespace ts { visitNodes(cbNode, cbNodes, node.typeParameters) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocTypedefTag] = forEachJSDocTypedefTag; function forEachJSDocTypedefTag(node: JSDocTypedefTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || @@ -1014,7 +1031,6 @@ namespace ts { visitNode(cbNode, node.typeExpression) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); } - forEachChildTable[SyntaxKind.JSDocCallbackTag] = forEachJSDocCallbackTag; function forEachJSDocCallbackTag(node: JSDocCallbackTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || @@ -1022,48 +1038,31 @@ namespace ts { visitNode(cbNode, node.typeExpression) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocReturnTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocTypeTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocThisTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocEnumTag] = forEachJSDocReturnTag; function forEachJSDocReturnTag(node: JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.typeExpression) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.JSDocSignature] = forEachJSDocSignature; function forEachJSDocSignature(node: JSDocSignature, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return forEach(node.typeParameters, cbNode) || forEach(node.parameters, cbNode) || visitNode(cbNode, node.type); } - forEachChildTable[SyntaxKind.JSDocLink] = forEachJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocLinkCode] = forEachJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocLinkPlain] = forEachJSDocLinkCodeOrPlain; function forEachJSDocLinkCodeOrPlain(node: JSDocLink | JSDocLinkCode | JSDocLinkPlain, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.name); } - forEachChildTable[SyntaxKind.JSDocTypeLiteral] = forEachJSDocTypeLiteral; function forEachJSDocTypeLiteral(node: JSDocTypeLiteral, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return forEach(node.jsDocPropertyTags, cbNode); } - forEachChildTable[SyntaxKind.JSDocTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocClassTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocPublicTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocPrivateTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocProtectedTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocReadonlyTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocDeprecatedTag] = forEachJSDocTag; function forEachJSDocTag(node: JSDocTag | JSDocClassTag | JSDocPublicTag | JSDocPrivateTag | JSDocProtectedTag | JSDocReadonlyTag | JSDocDeprecatedTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.tagName) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - forEachChildTable[SyntaxKind.PartiallyEmittedExpression] = forEachPartiallyEmittedExpression; function forEachPartiallyEmittedExpression(node: PartiallyEmittedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { return visitNode(cbNode, node.expression); From 85a093735244737ab11ead27f980afdcf4e7a4ae Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 9 Aug 2022 18:49:55 +0000 Subject: [PATCH 4/9] Try `push`ing undefined to create a packed Array. --- src/compiler/parser.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index be298aaf050e6..dc53215263b18 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -97,7 +97,8 @@ namespace ts { type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - const forEachChildTable = new Array(SyntaxKind.Count); + const forEachChildTable: Array = []; + for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(undefined); forEachChildTable[SyntaxKind.QualifiedName] = forEachQualifiedName; forEachChildTable[SyntaxKind.TypeParameter] = forEachTypeParameter; forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachShorthandPropertyAssignment; From 059572ab3699017669b580bc3dd9190a26653b87 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 9 Aug 2022 20:41:34 +0000 Subject: [PATCH 5/9] Try using an unconditional no-op function. --- src/compiler/parser.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index dc53215263b18..d7558c123856a 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -97,8 +97,9 @@ namespace ts { type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - const forEachChildTable: Array = []; - for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(undefined); + const forEachChildTable: (ForEachChildFunction | undefined)[] = []; + const forEachChildNoOpFn: ForEachChildFunction = (_node, _cbNode, _cbNodes) => undefined; + for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(forEachChildNoOpFn); forEachChildTable[SyntaxKind.QualifiedName] = forEachQualifiedName; forEachChildTable[SyntaxKind.TypeParameter] = forEachTypeParameter; forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachShorthandPropertyAssignment; From 79286ebd0c2a2d7783a6db20945a60e67e8e9fe7 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 9 Aug 2022 20:56:07 +0000 Subject: [PATCH 6/9] `forEach` -> `forEachChildIn` --- src/compiler/parser.ts | 616 ++++++++++++++++++++--------------------- 1 file changed, 308 insertions(+), 308 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index d7558c123856a..30907406b9c6c 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -100,181 +100,181 @@ namespace ts { const forEachChildTable: (ForEachChildFunction | undefined)[] = []; const forEachChildNoOpFn: ForEachChildFunction = (_node, _cbNode, _cbNodes) => undefined; for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(forEachChildNoOpFn); - forEachChildTable[SyntaxKind.QualifiedName] = forEachQualifiedName; - forEachChildTable[SyntaxKind.TypeParameter] = forEachTypeParameter; - forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachShorthandPropertyAssignment; - forEachChildTable[SyntaxKind.SpreadAssignment] = forEachSpreadAssignment; - forEachChildTable[SyntaxKind.Parameter] = forEachParameter; - forEachChildTable[SyntaxKind.PropertyDeclaration] = forEachPropertyDeclaration; - forEachChildTable[SyntaxKind.PropertySignature] = forEachPropertySignature; - forEachChildTable[SyntaxKind.PropertyAssignment] = forEachPropertyAssignment; - forEachChildTable[SyntaxKind.VariableDeclaration] = forEachVariableDeclaration; - forEachChildTable[SyntaxKind.BindingElement] = forEachBindingElement; - forEachChildTable[SyntaxKind.IndexSignature] = forEachIndexSignature; - forEachChildTable[SyntaxKind.ConstructorType] = forEachConstructorType; - forEachChildTable[SyntaxKind.FunctionType] = forEachFunctionType; - forEachChildTable[SyntaxKind.CallSignature] = forEachCallOrConstructSignature; - forEachChildTable[SyntaxKind.ConstructSignature] = forEachCallOrConstructSignature; - forEachChildTable[SyntaxKind.MethodDeclaration] = forEachMethodDeclaration; - forEachChildTable[SyntaxKind.MethodSignature] = forEachMethodSignature; - forEachChildTable[SyntaxKind.Constructor] = forEachConstructor; - forEachChildTable[SyntaxKind.GetAccessor] = forEachGetAccessor; - forEachChildTable[SyntaxKind.SetAccessor] = forEachSetAccessor; - forEachChildTable[SyntaxKind.FunctionDeclaration] = forEachFunctionDeclaration; - forEachChildTable[SyntaxKind.FunctionExpression] = forEachFunctionExpression; - forEachChildTable[SyntaxKind.ArrowFunction] = forEachArrowFunction; - forEachChildTable[SyntaxKind.ClassStaticBlockDeclaration] = forEachClassStaticBlockDeclaration; - forEachChildTable[SyntaxKind.TypeReference] = forEachTypeReference; - forEachChildTable[SyntaxKind.TypePredicate] = forEachTypePredicate; - forEachChildTable[SyntaxKind.TypeQuery] = forEachTypeQuery; - forEachChildTable[SyntaxKind.TypeLiteral] = forEachTypeLiteral; - forEachChildTable[SyntaxKind.ArrayType] = forEachArrayType; - forEachChildTable[SyntaxKind.TupleType] = forEachTupleType; - forEachChildTable[SyntaxKind.UnionType] = forEachUnionOrIntersectionType; - forEachChildTable[SyntaxKind.IntersectionType] = forEachUnionOrIntersectionType; - forEachChildTable[SyntaxKind.ConditionalType] = forEachConditionalType; - forEachChildTable[SyntaxKind.InferType] = forEachInferType; - forEachChildTable[SyntaxKind.ImportType] = forEachImportType; - forEachChildTable[SyntaxKind.ImportTypeAssertionContainer] = forEachImportTypeAssertionContainer; - forEachChildTable[SyntaxKind.ParenthesizedType] = forEachParenthesizedTypeOrTypeOperator; - forEachChildTable[SyntaxKind.TypeOperator] = forEachParenthesizedTypeOrTypeOperator; - forEachChildTable[SyntaxKind.IndexedAccessType] = forEachIndexedAccessType; - forEachChildTable[SyntaxKind.MappedType] = forEachMappedType; - forEachChildTable[SyntaxKind.LiteralType] = forEachLiteralType; - forEachChildTable[SyntaxKind.NamedTupleMember] = forEachNamedTupleMember; - forEachChildTable[SyntaxKind.ObjectBindingPattern] = forEachObjectOrArrayBindingPattern; - forEachChildTable[SyntaxKind.ArrayBindingPattern] = forEachObjectOrArrayBindingPattern; - forEachChildTable[SyntaxKind.ArrayLiteralExpression] = forEachArrayLiteralExpression; - forEachChildTable[SyntaxKind.ObjectLiteralExpression] = forEachObjectLiteralExpression; - forEachChildTable[SyntaxKind.PropertyAccessExpression] = forEachPropertyAccessExpression; - forEachChildTable[SyntaxKind.ElementAccessExpression] = forEachElementAccessExpression; - forEachChildTable[SyntaxKind.CallExpression] = forEachCallExpression; - forEachChildTable[SyntaxKind.NewExpression] = forEachCallExpression; - forEachChildTable[SyntaxKind.TaggedTemplateExpression] = forEachTaggedTemplateExpression; - forEachChildTable[SyntaxKind.TypeAssertionExpression] = forEachTypeAssertionExpression; - forEachChildTable[SyntaxKind.ParenthesizedExpression] = forEachParenthesizedExpression; - forEachChildTable[SyntaxKind.DeleteExpression] = forEachDeleteExpression; - forEachChildTable[SyntaxKind.TypeOfExpression] = forEachTypeOfExpression; - forEachChildTable[SyntaxKind.VoidExpression] = forEachVoidExpression; - forEachChildTable[SyntaxKind.PrefixUnaryExpression] = forEachPrefixUnaryExpression; - forEachChildTable[SyntaxKind.YieldExpression] = forEachYieldExpression; - forEachChildTable[SyntaxKind.AwaitExpression] = forEachAwaitExpression; - forEachChildTable[SyntaxKind.PostfixUnaryExpression] = forEachPostfixUnaryExpression; - forEachChildTable[SyntaxKind.BinaryExpression] = forEachBinaryExpression; - forEachChildTable[SyntaxKind.AsExpression] = forEachAsExpression; - forEachChildTable[SyntaxKind.NonNullExpression] = forEachNonNullExpression; - forEachChildTable[SyntaxKind.MetaProperty] = forEachMetaProperty; - forEachChildTable[SyntaxKind.ConditionalExpression] = forEachConditionalExpression; - forEachChildTable[SyntaxKind.SpreadElement] = forEachSpreadElement; - forEachChildTable[SyntaxKind.Block] = forEachBlock; - forEachChildTable[SyntaxKind.ModuleBlock] = forEachBlock; - forEachChildTable[SyntaxKind.SourceFile] = forEachSourceFile; - forEachChildTable[SyntaxKind.VariableStatement] = forEachVariableStatement; - forEachChildTable[SyntaxKind.VariableDeclarationList] = forEachVariableDeclarationList; - forEachChildTable[SyntaxKind.ExpressionStatement] = forEachExpressionStatement; - forEachChildTable[SyntaxKind.IfStatement] = forEachIfStatement; - forEachChildTable[SyntaxKind.DoStatement] = forEachDoStatement; - forEachChildTable[SyntaxKind.WhileStatement] = forEachWhileStatement; - forEachChildTable[SyntaxKind.ForStatement] = forEachForStatement; - forEachChildTable[SyntaxKind.ForInStatement] = forEachForInStatement; - forEachChildTable[SyntaxKind.ForOfStatement] = forEachForOfStatement; - forEachChildTable[SyntaxKind.ContinueStatement] = forEachContinueStatement; - forEachChildTable[SyntaxKind.BreakStatement] = forEachContinueStatement; - forEachChildTable[SyntaxKind.ReturnStatement] = forEachReturnStatement; - forEachChildTable[SyntaxKind.WithStatement] = forEachWithStatement; - forEachChildTable[SyntaxKind.SwitchStatement] = forEachSwitchStatement; - forEachChildTable[SyntaxKind.CaseBlock] = forEachCaseBlock; - forEachChildTable[SyntaxKind.CaseClause] = forEachCaseClause; - forEachChildTable[SyntaxKind.DefaultClause] = forEachDefaultClause; - forEachChildTable[SyntaxKind.LabeledStatement] = forEachLabeledStatement; - forEachChildTable[SyntaxKind.ThrowStatement] = forEachThrowStatement; - forEachChildTable[SyntaxKind.TryStatement] = forEachTryStatement; - forEachChildTable[SyntaxKind.CatchClause] = forEachCatchClause; - forEachChildTable[SyntaxKind.Decorator] = forEachDecorator; - forEachChildTable[SyntaxKind.ClassDeclaration] = forEachClassDeclarationOrExpression; - forEachChildTable[SyntaxKind.ClassExpression] = forEachClassDeclarationOrExpression; - forEachChildTable[SyntaxKind.InterfaceDeclaration] = forEachInterfaceDeclaration; - forEachChildTable[SyntaxKind.TypeAliasDeclaration] = forEachTypeAliasDeclaration; - forEachChildTable[SyntaxKind.EnumDeclaration] = forEachEnumDeclaration; - forEachChildTable[SyntaxKind.EnumMember] = forEachEnumMember; - forEachChildTable[SyntaxKind.ModuleDeclaration] = forEachModuleDeclaration; - forEachChildTable[SyntaxKind.ImportEqualsDeclaration] = forEachImportEqualsDeclaration; - forEachChildTable[SyntaxKind.ImportDeclaration] = forEachImportDeclaration; - forEachChildTable[SyntaxKind.ImportClause] = forEachImportClause; - forEachChildTable[SyntaxKind.AssertClause] = forEachAssertClause; - forEachChildTable[SyntaxKind.AssertEntry] = forEachAssertEntry; - forEachChildTable[SyntaxKind.NamespaceExportDeclaration] = forEachNamespaceExportDeclaration; - forEachChildTable[SyntaxKind.NamespaceImport] = forEachNamespaceImport; - forEachChildTable[SyntaxKind.NamespaceExport] = forEachNamespaceExport; - forEachChildTable[SyntaxKind.NamedImports] = forEachNamedImportsOrExports; - forEachChildTable[SyntaxKind.NamedExports] = forEachNamedImportsOrExports; - forEachChildTable[SyntaxKind.ExportDeclaration] = forEachExportDeclaration; - forEachChildTable[SyntaxKind.ImportSpecifier] = forEachImportOrExportSpecifier; - forEachChildTable[SyntaxKind.ExportSpecifier] = forEachImportOrExportSpecifier; - forEachChildTable[SyntaxKind.ExportAssignment] = forEachExportAssignment; - forEachChildTable[SyntaxKind.TemplateExpression] = forEachTemplateExpression; - forEachChildTable[SyntaxKind.TemplateSpan] = forEachTemplateSpan; - forEachChildTable[SyntaxKind.TemplateLiteralType] = forEachTemplateLiteralType; - forEachChildTable[SyntaxKind.TemplateLiteralTypeSpan] = forEachTemplateLiteralTypeSpan; - forEachChildTable[SyntaxKind.ComputedPropertyName] = forEachComputedPropertyName; - forEachChildTable[SyntaxKind.HeritageClause] = forEachHeritageClause; - forEachChildTable[SyntaxKind.ExpressionWithTypeArguments] = forEachExpressionWithTypeArguments; - forEachChildTable[SyntaxKind.ExternalModuleReference] = forEachExternalModuleReference; - forEachChildTable[SyntaxKind.MissingDeclaration] = forEachMissingDeclaration; - forEachChildTable[SyntaxKind.CommaListExpression] = forEachCommaListExpression; - forEachChildTable[SyntaxKind.JsxElement] = forEachJsxElement; - forEachChildTable[SyntaxKind.JsxFragment] = forEachJsxFragment; - forEachChildTable[SyntaxKind.JsxSelfClosingElement] = forEachJsxOpeningOrSelfClosingElement; - forEachChildTable[SyntaxKind.JsxOpeningElement] = forEachJsxOpeningOrSelfClosingElement; - forEachChildTable[SyntaxKind.JsxAttributes] = forEachJsxAttributes; - forEachChildTable[SyntaxKind.JsxAttribute] = forEachJsxAttribute; - forEachChildTable[SyntaxKind.JsxSpreadAttribute] = forEachJsxSpreadAttribute; - forEachChildTable[SyntaxKind.JsxExpression] = forEachJsxExpression; - forEachChildTable[SyntaxKind.JsxClosingElement] = forEachJsxClosingElement; - forEachChildTable[SyntaxKind.OptionalType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.RestType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocTypeExpression] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocNonNullableType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocNullableType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocOptionalType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocVariadicType] = forEachOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocFunctionType] = forEachJSDocFunctionType; - forEachChildTable[SyntaxKind.JSDoc] = forEachJSDoc; - forEachChildTable[SyntaxKind.JSDocSeeTag] = forEachJSDocSeeTag; - forEachChildTable[SyntaxKind.JSDocNameReference] = forEachJSDocNameReference; - forEachChildTable[SyntaxKind.JSDocMemberName] = forEachJSDocMemberName; - forEachChildTable[SyntaxKind.JSDocParameterTag] = forEachJSDocParameterOrPropertyTag; - forEachChildTable[SyntaxKind.JSDocPropertyTag] = forEachJSDocParameterOrPropertyTag; - forEachChildTable[SyntaxKind.JSDocAuthorTag] = forEachJSDocAuthorTag; - forEachChildTable[SyntaxKind.JSDocImplementsTag] = forEachJSDocImplementsTag; - forEachChildTable[SyntaxKind.JSDocAugmentsTag] = forEachJSDocAugmentsTag; - forEachChildTable[SyntaxKind.JSDocTemplateTag] = forEachJSDocTemplateTag; - forEachChildTable[SyntaxKind.JSDocTypedefTag] = forEachJSDocTypedefTag; - forEachChildTable[SyntaxKind.JSDocCallbackTag] = forEachJSDocCallbackTag; - forEachChildTable[SyntaxKind.JSDocReturnTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocTypeTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocThisTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocEnumTag] = forEachJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocSignature] = forEachJSDocSignature; - forEachChildTable[SyntaxKind.JSDocLink] = forEachJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocLinkCode] = forEachJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocLinkPlain] = forEachJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocTypeLiteral] = forEachJSDocTypeLiteral; - forEachChildTable[SyntaxKind.JSDocTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocClassTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocPublicTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocPrivateTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocProtectedTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocReadonlyTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.JSDocDeprecatedTag] = forEachJSDocTag; - forEachChildTable[SyntaxKind.PartiallyEmittedExpression] = forEachPartiallyEmittedExpression; - - function forEachQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + forEachChildTable[SyntaxKind.QualifiedName] = forEachChildInQualifiedName; + forEachChildTable[SyntaxKind.TypeParameter] = forEachChildInTypeParameter; + forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachChildInShorthandPropertyAssignment; + forEachChildTable[SyntaxKind.SpreadAssignment] = forEachChildInSpreadAssignment; + forEachChildTable[SyntaxKind.Parameter] = forEachChildInParameter; + forEachChildTable[SyntaxKind.PropertyDeclaration] = forEachChildInPropertyDeclaration; + forEachChildTable[SyntaxKind.PropertySignature] = forEachChildInPropertySignature; + forEachChildTable[SyntaxKind.PropertyAssignment] = forEachChildInPropertyAssignment; + forEachChildTable[SyntaxKind.VariableDeclaration] = forEachChildInVariableDeclaration; + forEachChildTable[SyntaxKind.BindingElement] = forEachChildInBindingElement; + forEachChildTable[SyntaxKind.IndexSignature] = forEachChildInIndexSignature; + forEachChildTable[SyntaxKind.ConstructorType] = forEachChildInConstructorType; + forEachChildTable[SyntaxKind.FunctionType] = forEachChildInFunctionType; + forEachChildTable[SyntaxKind.CallSignature] = forEachChildInCallOrConstructSignature; + forEachChildTable[SyntaxKind.ConstructSignature] = forEachChildInCallOrConstructSignature; + forEachChildTable[SyntaxKind.MethodDeclaration] = forEachChildInMethodDeclaration; + forEachChildTable[SyntaxKind.MethodSignature] = forEachChildInMethodSignature; + forEachChildTable[SyntaxKind.Constructor] = forEachChildInConstructor; + forEachChildTable[SyntaxKind.GetAccessor] = forEachChildInGetAccessor; + forEachChildTable[SyntaxKind.SetAccessor] = forEachChildInSetAccessor; + forEachChildTable[SyntaxKind.FunctionDeclaration] = forEachChildInFunctionDeclaration; + forEachChildTable[SyntaxKind.FunctionExpression] = forEachChildInFunctionExpression; + forEachChildTable[SyntaxKind.ArrowFunction] = forEachChildInArrowFunction; + forEachChildTable[SyntaxKind.ClassStaticBlockDeclaration] = forEachChildInClassStaticBlockDeclaration; + forEachChildTable[SyntaxKind.TypeReference] = forEachChildInTypeReference; + forEachChildTable[SyntaxKind.TypePredicate] = forEachChildInTypePredicate; + forEachChildTable[SyntaxKind.TypeQuery] = forEachChildInTypeQuery; + forEachChildTable[SyntaxKind.TypeLiteral] = forEachChildInTypeLiteral; + forEachChildTable[SyntaxKind.ArrayType] = forEachChildInArrayType; + forEachChildTable[SyntaxKind.TupleType] = forEachChildInTupleType; + forEachChildTable[SyntaxKind.UnionType] = forEachChildInUnionOrIntersectionType; + forEachChildTable[SyntaxKind.IntersectionType] = forEachChildInUnionOrIntersectionType; + forEachChildTable[SyntaxKind.ConditionalType] = forEachChildInConditionalType; + forEachChildTable[SyntaxKind.InferType] = forEachChildInInferType; + forEachChildTable[SyntaxKind.ImportType] = forEachChildInImportType; + forEachChildTable[SyntaxKind.ImportTypeAssertionContainer] = forEachChildInImportTypeAssertionContainer; + forEachChildTable[SyntaxKind.ParenthesizedType] = forEachChildInParenthesizedTypeOrTypeOperator; + forEachChildTable[SyntaxKind.TypeOperator] = forEachChildInParenthesizedTypeOrTypeOperator; + forEachChildTable[SyntaxKind.IndexedAccessType] = forEachChildInIndexedAccessType; + forEachChildTable[SyntaxKind.MappedType] = forEachChildInMappedType; + forEachChildTable[SyntaxKind.LiteralType] = forEachChildInLiteralType; + forEachChildTable[SyntaxKind.NamedTupleMember] = forEachChildInNamedTupleMember; + forEachChildTable[SyntaxKind.ObjectBindingPattern] = forEachChildInObjectOrArrayBindingPattern; + forEachChildTable[SyntaxKind.ArrayBindingPattern] = forEachChildInObjectOrArrayBindingPattern; + forEachChildTable[SyntaxKind.ArrayLiteralExpression] = forEachChildInArrayLiteralExpression; + forEachChildTable[SyntaxKind.ObjectLiteralExpression] = forEachChildInObjectLiteralExpression; + forEachChildTable[SyntaxKind.PropertyAccessExpression] = forEachChildInPropertyAccessExpression; + forEachChildTable[SyntaxKind.ElementAccessExpression] = forEachChildInElementAccessExpression; + forEachChildTable[SyntaxKind.CallExpression] = forEachChildInCallExpression; + forEachChildTable[SyntaxKind.NewExpression] = forEachChildInCallExpression; + forEachChildTable[SyntaxKind.TaggedTemplateExpression] = forEachChildInTaggedTemplateExpression; + forEachChildTable[SyntaxKind.TypeAssertionExpression] = forEachChildInTypeAssertionExpression; + forEachChildTable[SyntaxKind.ParenthesizedExpression] = forEachChildInParenthesizedExpression; + forEachChildTable[SyntaxKind.DeleteExpression] = forEachChildInDeleteExpression; + forEachChildTable[SyntaxKind.TypeOfExpression] = forEachChildInTypeOfExpression; + forEachChildTable[SyntaxKind.VoidExpression] = forEachChildInVoidExpression; + forEachChildTable[SyntaxKind.PrefixUnaryExpression] = forEachChildInPrefixUnaryExpression; + forEachChildTable[SyntaxKind.YieldExpression] = forEachChildInYieldExpression; + forEachChildTable[SyntaxKind.AwaitExpression] = forEachChildInAwaitExpression; + forEachChildTable[SyntaxKind.PostfixUnaryExpression] = forEachChildInPostfixUnaryExpression; + forEachChildTable[SyntaxKind.BinaryExpression] = forEachChildInBinaryExpression; + forEachChildTable[SyntaxKind.AsExpression] = forEachChildInAsExpression; + forEachChildTable[SyntaxKind.NonNullExpression] = forEachChildInNonNullExpression; + forEachChildTable[SyntaxKind.MetaProperty] = forEachChildInMetaProperty; + forEachChildTable[SyntaxKind.ConditionalExpression] = forEachChildInConditionalExpression; + forEachChildTable[SyntaxKind.SpreadElement] = forEachChildInSpreadElement; + forEachChildTable[SyntaxKind.Block] = forEachChildInBlock; + forEachChildTable[SyntaxKind.ModuleBlock] = forEachChildInBlock; + forEachChildTable[SyntaxKind.SourceFile] = forEachChildInSourceFile; + forEachChildTable[SyntaxKind.VariableStatement] = forEachChildInVariableStatement; + forEachChildTable[SyntaxKind.VariableDeclarationList] = forEachChildInVariableDeclarationList; + forEachChildTable[SyntaxKind.ExpressionStatement] = forEachChildInExpressionStatement; + forEachChildTable[SyntaxKind.IfStatement] = forEachChildInIfStatement; + forEachChildTable[SyntaxKind.DoStatement] = forEachChildInDoStatement; + forEachChildTable[SyntaxKind.WhileStatement] = forEachChildInWhileStatement; + forEachChildTable[SyntaxKind.ForStatement] = forEachChildInForStatement; + forEachChildTable[SyntaxKind.ForInStatement] = forEachChildInForInStatement; + forEachChildTable[SyntaxKind.ForOfStatement] = forEachChildInForOfStatement; + forEachChildTable[SyntaxKind.ContinueStatement] = forEachChildInContinueStatement; + forEachChildTable[SyntaxKind.BreakStatement] = forEachChildInContinueStatement; + forEachChildTable[SyntaxKind.ReturnStatement] = forEachChildInReturnStatement; + forEachChildTable[SyntaxKind.WithStatement] = forEachChildInWithStatement; + forEachChildTable[SyntaxKind.SwitchStatement] = forEachChildInSwitchStatement; + forEachChildTable[SyntaxKind.CaseBlock] = forEachChildInCaseBlock; + forEachChildTable[SyntaxKind.CaseClause] = forEachChildInCaseClause; + forEachChildTable[SyntaxKind.DefaultClause] = forEachChildInDefaultClause; + forEachChildTable[SyntaxKind.LabeledStatement] = forEachChildInLabeledStatement; + forEachChildTable[SyntaxKind.ThrowStatement] = forEachChildInThrowStatement; + forEachChildTable[SyntaxKind.TryStatement] = forEachChildInTryStatement; + forEachChildTable[SyntaxKind.CatchClause] = forEachChildInCatchClause; + forEachChildTable[SyntaxKind.Decorator] = forEachChildInDecorator; + forEachChildTable[SyntaxKind.ClassDeclaration] = forEachChildInClassDeclarationOrExpression; + forEachChildTable[SyntaxKind.ClassExpression] = forEachChildInClassDeclarationOrExpression; + forEachChildTable[SyntaxKind.InterfaceDeclaration] = forEachChildInInterfaceDeclaration; + forEachChildTable[SyntaxKind.TypeAliasDeclaration] = forEachChildInTypeAliasDeclaration; + forEachChildTable[SyntaxKind.EnumDeclaration] = forEachChildInEnumDeclaration; + forEachChildTable[SyntaxKind.EnumMember] = forEachChildInEnumMember; + forEachChildTable[SyntaxKind.ModuleDeclaration] = forEachChildInModuleDeclaration; + forEachChildTable[SyntaxKind.ImportEqualsDeclaration] = forEachChildInImportEqualsDeclaration; + forEachChildTable[SyntaxKind.ImportDeclaration] = forEachChildInImportDeclaration; + forEachChildTable[SyntaxKind.ImportClause] = forEachChildInImportClause; + forEachChildTable[SyntaxKind.AssertClause] = forEachChildInAssertClause; + forEachChildTable[SyntaxKind.AssertEntry] = forEachChildInAssertEntry; + forEachChildTable[SyntaxKind.NamespaceExportDeclaration] = forEachChildInNamespaceExportDeclaration; + forEachChildTable[SyntaxKind.NamespaceImport] = forEachChildInNamespaceImport; + forEachChildTable[SyntaxKind.NamespaceExport] = forEachChildInNamespaceExport; + forEachChildTable[SyntaxKind.NamedImports] = forEachChildInNamedImportsOrExports; + forEachChildTable[SyntaxKind.NamedExports] = forEachChildInNamedImportsOrExports; + forEachChildTable[SyntaxKind.ExportDeclaration] = forEachChildInExportDeclaration; + forEachChildTable[SyntaxKind.ImportSpecifier] = forEachChildInImportOrExportSpecifier; + forEachChildTable[SyntaxKind.ExportSpecifier] = forEachChildInImportOrExportSpecifier; + forEachChildTable[SyntaxKind.ExportAssignment] = forEachChildInExportAssignment; + forEachChildTable[SyntaxKind.TemplateExpression] = forEachChildInTemplateExpression; + forEachChildTable[SyntaxKind.TemplateSpan] = forEachChildInTemplateSpan; + forEachChildTable[SyntaxKind.TemplateLiteralType] = forEachChildInTemplateLiteralType; + forEachChildTable[SyntaxKind.TemplateLiteralTypeSpan] = forEachChildInTemplateLiteralTypeSpan; + forEachChildTable[SyntaxKind.ComputedPropertyName] = forEachChildInComputedPropertyName; + forEachChildTable[SyntaxKind.HeritageClause] = forEachChildInHeritageClause; + forEachChildTable[SyntaxKind.ExpressionWithTypeArguments] = forEachChildInExpressionWithTypeArguments; + forEachChildTable[SyntaxKind.ExternalModuleReference] = forEachChildInExternalModuleReference; + forEachChildTable[SyntaxKind.MissingDeclaration] = forEachChildInMissingDeclaration; + forEachChildTable[SyntaxKind.CommaListExpression] = forEachChildInCommaListExpression; + forEachChildTable[SyntaxKind.JsxElement] = forEachChildInJsxElement; + forEachChildTable[SyntaxKind.JsxFragment] = forEachChildInJsxFragment; + forEachChildTable[SyntaxKind.JsxSelfClosingElement] = forEachChildInJsxOpeningOrSelfClosingElement; + forEachChildTable[SyntaxKind.JsxOpeningElement] = forEachChildInJsxOpeningOrSelfClosingElement; + forEachChildTable[SyntaxKind.JsxAttributes] = forEachChildInJsxAttributes; + forEachChildTable[SyntaxKind.JsxAttribute] = forEachChildInJsxAttribute; + forEachChildTable[SyntaxKind.JsxSpreadAttribute] = forEachChildInJsxSpreadAttribute; + forEachChildTable[SyntaxKind.JsxExpression] = forEachChildInJsxExpression; + forEachChildTable[SyntaxKind.JsxClosingElement] = forEachChildInJsxClosingElement; + forEachChildTable[SyntaxKind.OptionalType] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.RestType] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocTypeExpression] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocNonNullableType] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocNullableType] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocOptionalType] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocVariadicType] = forEachChildInOptionalRestOrJSDocParameterModifier; + forEachChildTable[SyntaxKind.JSDocFunctionType] = forEachChildInJSDocFunctionType; + forEachChildTable[SyntaxKind.JSDoc] = forEachChildInJSDoc; + forEachChildTable[SyntaxKind.JSDocSeeTag] = forEachChildInJSDocSeeTag; + forEachChildTable[SyntaxKind.JSDocNameReference] = forEachChildInJSDocNameReference; + forEachChildTable[SyntaxKind.JSDocMemberName] = forEachChildInJSDocMemberName; + forEachChildTable[SyntaxKind.JSDocParameterTag] = forEachChildInJSDocParameterOrPropertyTag; + forEachChildTable[SyntaxKind.JSDocPropertyTag] = forEachChildInJSDocParameterOrPropertyTag; + forEachChildTable[SyntaxKind.JSDocAuthorTag] = forEachChildInJSDocAuthorTag; + forEachChildTable[SyntaxKind.JSDocImplementsTag] = forEachChildInJSDocImplementsTag; + forEachChildTable[SyntaxKind.JSDocAugmentsTag] = forEachChildInJSDocAugmentsTag; + forEachChildTable[SyntaxKind.JSDocTemplateTag] = forEachChildInJSDocTemplateTag; + forEachChildTable[SyntaxKind.JSDocTypedefTag] = forEachChildInJSDocTypedefTag; + forEachChildTable[SyntaxKind.JSDocCallbackTag] = forEachChildInJSDocCallbackTag; + forEachChildTable[SyntaxKind.JSDocReturnTag] = forEachChildInJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocTypeTag] = forEachChildInJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocThisTag] = forEachChildInJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocEnumTag] = forEachChildInJSDocReturnTag; + forEachChildTable[SyntaxKind.JSDocSignature] = forEachChildInJSDocSignature; + forEachChildTable[SyntaxKind.JSDocLink] = forEachChildInJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocLinkCode] = forEachChildInJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocLinkPlain] = forEachChildInJSDocLinkCodeOrPlain; + forEachChildTable[SyntaxKind.JSDocTypeLiteral] = forEachChildInJSDocTypeLiteral; + forEachChildTable[SyntaxKind.JSDocTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.JSDocClassTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.JSDocPublicTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.JSDocPrivateTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.JSDocProtectedTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.JSDocReadonlyTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.JSDocDeprecatedTag] = forEachChildInJSDocTag; + forEachChildTable[SyntaxKind.PartiallyEmittedExpression] = forEachChildInPartiallyEmittedExpression; + + function forEachChildInQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); } - function forEachTypeParameter(node: TypeParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeParameter(node: TypeParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || @@ -282,7 +282,7 @@ namespace ts { visitNode(cbNode, node.expression); } - function forEachShorthandPropertyAssignment(node: ShorthandPropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInShorthandPropertyAssignment(node: ShorthandPropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || @@ -292,11 +292,11 @@ namespace ts { visitNode(cbNode, node.objectAssignmentInitializer); } - function forEachSpreadAssignment(node: SpreadAssignment, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInSpreadAssignment(node: SpreadAssignment, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachParameter(node: ParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInParameter(node: ParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.name) || @@ -305,7 +305,7 @@ namespace ts { visitNode(cbNode, node.initializer); } - function forEachPropertyDeclaration(node: PropertyDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPropertyDeclaration(node: PropertyDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || @@ -314,7 +314,7 @@ namespace ts { visitNode(cbNode, node.initializer); } - function forEachPropertySignature(node: PropertySignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPropertySignature(node: PropertySignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || @@ -322,7 +322,7 @@ namespace ts { visitNode(cbNode, node.initializer); } - function forEachPropertyAssignment(node: PropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPropertyAssignment(node: PropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || @@ -331,48 +331,48 @@ namespace ts { visitNode(cbNode, node.initializer); } - function forEachVariableDeclaration(node: VariableDeclaration, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInVariableDeclaration(node: VariableDeclaration, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name) || visitNode(cbNode, node.exclamationToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); } - function forEachBindingElement(node: BindingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInBindingElement(node: BindingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); } - function forEachIndexSignature(node: IndexSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInIndexSignature(node: IndexSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - function forEachConstructorType(node: ConstructorTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInConstructorType(node: ConstructorTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - function forEachFunctionType(node: FunctionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInFunctionType(node: FunctionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - function forEachCallOrConstructSignature(node: CallSignatureDeclaration | ConstructSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInCallOrConstructSignature(node: CallSignatureDeclaration | ConstructSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - function forEachMethodDeclaration(node: MethodDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInMethodDeclaration(node: MethodDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || @@ -384,7 +384,7 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachMethodSignature(node: MethodSignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInMethodSignature(node: MethodSignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || @@ -393,7 +393,7 @@ namespace ts { visitNode(cbNode, node.type); } - function forEachConstructor(node: ConstructorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInConstructor(node: ConstructorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || @@ -403,7 +403,7 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachGetAccessor(node: GetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInGetAccessor(node: GetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || @@ -412,7 +412,7 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachSetAccessor(node: SetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInSetAccessor(node: SetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || @@ -421,7 +421,7 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachFunctionDeclaration(node: FunctionDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInFunctionDeclaration(node: FunctionDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || @@ -432,7 +432,7 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachFunctionExpression(node: FunctionExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInFunctionExpression(node: FunctionExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || @@ -442,7 +442,7 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachArrowFunction(node: ArrowFunction, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInArrowFunction(node: ArrowFunction, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || @@ -451,76 +451,76 @@ namespace ts { visitNode(cbNode, node.body); } - function forEachClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.body); } - function forEachTypeReference(node: TypeReferenceNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeReference(node: TypeReferenceNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.typeName) || visitNodes(cbNode, cbNodes, node.typeArguments); } - function forEachTypePredicate(node: TypePredicateNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypePredicate(node: TypePredicateNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.assertsModifier) || visitNode(cbNode, node.parameterName) || visitNode(cbNode, node.type); } - function forEachTypeQuery(node: TypeQueryNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeQuery(node: TypeQueryNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.exprName) || visitNodes(cbNode, cbNodes, node.typeArguments); } - function forEachTypeLiteral(node: TypeLiteralNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeLiteral(node: TypeLiteralNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.members); } - function forEachArrayType(node: ArrayTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInArrayType(node: ArrayTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.elementType); } - function forEachTupleType(node: TupleTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTupleType(node: TupleTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.elements); } - function forEachUnionOrIntersectionType(node: UnionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInUnionOrIntersectionType(node: UnionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.types); } - function forEachConditionalType(node: ConditionalTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInConditionalType(node: ConditionalTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.checkType) || visitNode(cbNode, node.extendsType) || visitNode(cbNode, node.trueType) || visitNode(cbNode, node.falseType); } - function forEachInferType(node: InferTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInInferType(node: InferTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.typeParameter); } - function forEachImportType(node: ImportTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInImportType(node: ImportTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.argument) || visitNode(cbNode, node.assertions) || visitNode(cbNode, node.qualifier) || visitNodes(cbNode, cbNodes, node.typeArguments); } - function forEachImportTypeAssertionContainer(node: ImportTypeAssertionContainer, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInImportTypeAssertionContainer(node: ImportTypeAssertionContainer, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.assertClause); } - function forEachParenthesizedTypeOrTypeOperator(node: ParenthesizedTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInParenthesizedTypeOrTypeOperator(node: ParenthesizedTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, (node as ParenthesizedTypeNode | TypeOperatorNode).type); } - function forEachIndexedAccessType(node: IndexedAccessTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInIndexedAccessType(node: IndexedAccessTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.objectType) || visitNode(cbNode, node.indexType); } - function forEachMappedType(node: MappedTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInMappedType(node: MappedTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.readonlyToken) || visitNode(cbNode, node.typeParameter) || visitNode(cbNode, node.nameType) || @@ -529,113 +529,113 @@ namespace ts { visitNodes(cbNode, cbNodes, node.members); } - function forEachLiteralType(node: LiteralTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInLiteralType(node: LiteralTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.literal); } - function forEachNamedTupleMember(node: NamedTupleMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInNamedTupleMember(node: NamedTupleMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type); } - function forEachObjectOrArrayBindingPattern(node: ObjectBindingPattern, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInObjectOrArrayBindingPattern(node: ObjectBindingPattern, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.elements); } - function forEachArrayLiteralExpression(node: ArrayLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInArrayLiteralExpression(node: ArrayLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.elements); } - function forEachObjectLiteralExpression(node: ObjectLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInObjectLiteralExpression(node: ObjectLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.properties); } - function forEachPropertyAccessExpression(node: PropertyAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPropertyAccessExpression(node: PropertyAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.questionDotToken) || visitNode(cbNode, node.name); } - function forEachElementAccessExpression(node: ElementAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInElementAccessExpression(node: ElementAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.questionDotToken) || visitNode(cbNode, node.argumentExpression); } - function forEachCallExpression(node: CallExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInCallExpression(node: CallExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.questionDotToken) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNodes(cbNode, cbNodes, node.arguments); } - function forEachTaggedTemplateExpression(node: TaggedTemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTaggedTemplateExpression(node: TaggedTemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tag) || visitNode(cbNode, node.questionDotToken) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode(cbNode, node.template); } - function forEachTypeAssertionExpression(node: TypeAssertion, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeAssertionExpression(node: TypeAssertion, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); } - function forEachParenthesizedExpression(node: ParenthesizedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInParenthesizedExpression(node: ParenthesizedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachDeleteExpression(node: DeleteExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInDeleteExpression(node: DeleteExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachTypeOfExpression(node: TypeOfExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeOfExpression(node: TypeOfExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachVoidExpression(node: VoidExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInVoidExpression(node: VoidExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachPrefixUnaryExpression(node: PrefixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPrefixUnaryExpression(node: PrefixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.operand); } - function forEachYieldExpression(node: YieldExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInYieldExpression(node: YieldExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); } - function forEachAwaitExpression(node: AwaitExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInAwaitExpression(node: AwaitExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachPostfixUnaryExpression(node: PostfixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPostfixUnaryExpression(node: PostfixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.operand); } - function forEachBinaryExpression(node: BinaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInBinaryExpression(node: BinaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); } - function forEachAsExpression(node: AsExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInAsExpression(node: AsExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.type); } - function forEachNonNullExpression(node: NonNullExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInNonNullExpression(node: NonNullExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachMetaProperty(node: MetaProperty, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInMetaProperty(node: MetaProperty, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name); } - function forEachConditionalExpression(node: ConditionalExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInConditionalExpression(node: ConditionalExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.condition) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.whenTrue) || @@ -643,125 +643,125 @@ namespace ts { visitNode(cbNode, node.whenFalse); } - function forEachSpreadElement(node: SpreadElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInSpreadElement(node: SpreadElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachBlock(node: Block, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInBlock(node: Block, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.statements); } - function forEachSourceFile(node: SourceFile, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInSourceFile(node: SourceFile, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); } - function forEachVariableStatement(node: VariableStatement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInVariableStatement(node: VariableStatement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); } - function forEachVariableDeclarationList(node: VariableDeclarationList, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInVariableDeclarationList(node: VariableDeclarationList, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.declarations); } - function forEachExpressionStatement(node: ExpressionStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInExpressionStatement(node: ExpressionStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachIfStatement(node: IfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInIfStatement(node: IfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); } - function forEachDoStatement(node: DoStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInDoStatement(node: DoStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); } - function forEachWhileStatement(node: WhileStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInWhileStatement(node: WhileStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - function forEachForStatement(node: ForStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInForStatement(node: ForStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.incrementor) || visitNode(cbNode, node.statement); } - function forEachForInStatement(node: ForInStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInForInStatement(node: ForInStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - function forEachForOfStatement(node: ForOfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInForOfStatement(node: ForOfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.awaitModifier) || visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - function forEachContinueStatement(node: ContinueStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInContinueStatement(node: ContinueStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.label); } - function forEachReturnStatement(node: ReturnStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInReturnStatement(node: ReturnStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachWithStatement(node: WithStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInWithStatement(node: WithStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); } - function forEachSwitchStatement(node: SwitchStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInSwitchStatement(node: SwitchStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.caseBlock); } - function forEachCaseBlock(node: CaseBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInCaseBlock(node: CaseBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.clauses); } - function forEachCaseClause(node: CaseClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInCaseClause(node: CaseClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.statements); } - function forEachDefaultClause(node: DefaultClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInDefaultClause(node: DefaultClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.statements); } - function forEachLabeledStatement(node: LabeledStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInLabeledStatement(node: LabeledStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); } - function forEachThrowStatement(node: ThrowStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInThrowStatement(node: ThrowStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachTryStatement(node: TryStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTryStatement(node: TryStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); } - function forEachCatchClause(node: CatchClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInCatchClause(node: CatchClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.variableDeclaration) || visitNode(cbNode, node.block); } - function forEachDecorator(node: Decorator, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInDecorator(node: Decorator, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachClassDeclarationOrExpression(node: ClassDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInClassDeclarationOrExpression(node: ClassDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || @@ -769,7 +769,7 @@ namespace ts { visitNodes(cbNode, cbNodes, node.members); } - function forEachInterfaceDeclaration(node: InterfaceDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInInterfaceDeclaration(node: InterfaceDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || @@ -778,7 +778,7 @@ namespace ts { visitNodes(cbNode, cbNodes, node.members); } - function forEachTypeAliasDeclaration(node: TypeAliasDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTypeAliasDeclaration(node: TypeAliasDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || @@ -786,33 +786,33 @@ namespace ts { visitNode(cbNode, node.type); } - function forEachEnumDeclaration(node: EnumDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInEnumDeclaration(node: EnumDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.members); } - function forEachEnumMember(node: EnumMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInEnumMember(node: EnumMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); } - function forEachModuleDeclaration(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInModuleDeclaration(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); } - function forEachImportEqualsDeclaration(node: ImportEqualsDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInImportEqualsDeclaration(node: ImportEqualsDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); } - function forEachImportDeclaration(node: ImportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInImportDeclaration(node: ImportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.importClause) || @@ -820,38 +820,38 @@ namespace ts { visitNode(cbNode, node.assertClause); } - function forEachImportClause(node: ImportClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInImportClause(node: ImportClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name) || visitNode(cbNode, node.namedBindings); } - function forEachAssertClause(node: AssertClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInAssertClause(node: AssertClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.elements); } - function forEachAssertEntry(node: AssertEntry, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInAssertEntry(node: AssertEntry, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name) || visitNode(cbNode, node.value); } - function forEachNamespaceExportDeclaration(node: NamespaceExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInNamespaceExportDeclaration(node: NamespaceExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNode(cbNode, node.name); } - function forEachNamespaceImport(node: NamespaceImport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInNamespaceImport(node: NamespaceImport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name); } - function forEachNamespaceExport(node: NamespaceExport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInNamespaceExport(node: NamespaceExport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name); } - function forEachNamedImportsOrExports(node: NamedImports, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInNamedImportsOrExports(node: NamedImports, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.elements); } - function forEachExportDeclaration(node: ExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInExportDeclaration(node: ExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.exportClause) || @@ -859,135 +859,135 @@ namespace ts { visitNode(cbNode, node.assertClause); } - function forEachImportOrExportSpecifier(node: ImportSpecifier, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInImportOrExportSpecifier(node: ImportSpecifier, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.name); } - function forEachExportAssignment(node: ExportAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInExportAssignment(node: ExportAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode(cbNode, node.expression); } - function forEachTemplateExpression(node: TemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTemplateExpression(node: TemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans); } - function forEachTemplateSpan(node: TemplateSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTemplateSpan(node: TemplateSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); } - function forEachTemplateLiteralType(node: TemplateLiteralTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTemplateLiteralType(node: TemplateLiteralTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans); } - function forEachTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.type) || visitNode(cbNode, node.literal); } - function forEachComputedPropertyName(node: ComputedPropertyName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInComputedPropertyName(node: ComputedPropertyName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachHeritageClause(node: HeritageClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInHeritageClause(node: HeritageClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.types); } - function forEachExpressionWithTypeArguments(node: ExpressionWithTypeArguments, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInExpressionWithTypeArguments(node: ExpressionWithTypeArguments, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.typeArguments); } - function forEachExternalModuleReference(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInExternalModuleReference(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachMissingDeclaration(node: MissingDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInMissingDeclaration(node: MissingDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.decorators) || visitNodes(cbNode, cbNodes, node.modifiers); } - function forEachCommaListExpression(node: CommaListExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInCommaListExpression(node: CommaListExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.elements); } - function forEachJsxElement(node: JsxElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxElement(node: JsxElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.openingElement) || visitNodes(cbNode, cbNodes, node.children) || visitNode(cbNode, node.closingElement); } - function forEachJsxFragment(node: JsxFragment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxFragment(node: JsxFragment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.openingFragment) || visitNodes(cbNode, cbNodes, node.children) || visitNode(cbNode, node.closingFragment); } - function forEachJsxOpeningOrSelfClosingElement(node: JsxOpeningLikeElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxOpeningOrSelfClosingElement(node: JsxOpeningLikeElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode(cbNode, node.attributes); } - function forEachJsxAttributes(node: JsxAttributes, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxAttributes(node: JsxAttributes, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.properties); } - function forEachJsxAttribute(node: JsxAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxAttribute(node: JsxAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); } - function forEachJsxSpreadAttribute(node: JsxSpreadAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxSpreadAttribute(node: JsxSpreadAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } - function forEachJsxExpression(node: JsxExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxExpression(node: JsxExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.expression); } - function forEachJsxClosingElement(node: JsxClosingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJsxClosingElement(node: JsxClosingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName); } - function forEachOptionalRestOrJSDocParameterModifier(node: OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInOptionalRestOrJSDocParameterModifier(node: OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.type); } - function forEachJSDocFunctionType(node: JSDocFunctionType, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocFunctionType(node: JSDocFunctionType, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNodes(cbNode, cbNodes, node.parameters) || visitNode(cbNode, node.type); } - function forEachJSDoc(node: JSDoc, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDoc(node: JSDoc, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) || visitNodes(cbNode, cbNodes, node.tags); } - function forEachJSDocSeeTag(node: JSDocSeeTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocSeeTag(node: JSDocSeeTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.name) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocNameReference(node: JSDocNameReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocNameReference(node: JSDocNameReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name); } - function forEachJSDocMemberName(node: JSDocMemberName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocMemberName(node: JSDocMemberName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); } - function forEachJSDocParameterOrPropertyTag(node: JSDocParameterTag | JSDocPropertyTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocParameterOrPropertyTag(node: JSDocParameterTag | JSDocPropertyTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || (node.isNameFirst ? visitNode(cbNode, node.name) || @@ -998,31 +998,31 @@ namespace ts { (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); } - function forEachJSDocAuthorTag(node: JSDocAuthorTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocAuthorTag(node: JSDocAuthorTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocImplementsTag(node: JSDocImplementsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocImplementsTag(node: JSDocImplementsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.class) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocAugmentsTag(node: JSDocAugmentsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocAugmentsTag(node: JSDocAugmentsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.class) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocTemplateTag(node: JSDocTemplateTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocTemplateTag(node: JSDocTemplateTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.constraint) || visitNodes(cbNode, cbNodes, node.typeParameters) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocTypedefTag(node: JSDocTypedefTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocTypedefTag(node: JSDocTypedefTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || (node.typeExpression && node.typeExpression.kind === SyntaxKind.JSDocTypeExpression @@ -1034,39 +1034,39 @@ namespace ts { (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); } - function forEachJSDocCallbackTag(node: JSDocCallbackTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocCallbackTag(node: JSDocCallbackTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.fullName) || visitNode(cbNode, node.typeExpression) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocReturnTag(node: JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocReturnTag(node: JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || visitNode(cbNode, node.typeExpression) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachJSDocSignature(node: JSDocSignature, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocSignature(node: JSDocSignature, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return forEach(node.typeParameters, cbNode) || forEach(node.parameters, cbNode) || visitNode(cbNode, node.type); } - function forEachJSDocLinkCodeOrPlain(node: JSDocLink | JSDocLinkCode | JSDocLinkPlain, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocLinkCodeOrPlain(node: JSDocLink | JSDocLinkCode | JSDocLinkPlain, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.name); } - function forEachJSDocTypeLiteral(node: JSDocTypeLiteral, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocTypeLiteral(node: JSDocTypeLiteral, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return forEach(node.jsDocPropertyTags, cbNode); } - function forEachJSDocTag(node: JSDocTag | JSDocClassTag | JSDocPublicTag | JSDocPrivateTag | JSDocProtectedTag | JSDocReadonlyTag | JSDocDeprecatedTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInJSDocTag(node: JSDocTag | JSDocClassTag | JSDocPublicTag | JSDocPrivateTag | JSDocProtectedTag | JSDocReadonlyTag | JSDocDeprecatedTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.tagName) || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); } - function forEachPartiallyEmittedExpression(node: PartiallyEmittedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined) { + function forEachChildInPartiallyEmittedExpression(node: PartiallyEmittedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.expression); } From 6269b365a2880b79ba55905992258b9b2aa32bb0 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 9 Aug 2022 20:58:31 +0000 Subject: [PATCH 7/9] Remove the optional chain if we are pre-filling with no-ops. --- src/compiler/parser.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 30907406b9c6c..5df3b91b96b31 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -97,7 +97,7 @@ namespace ts { type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - const forEachChildTable: (ForEachChildFunction | undefined)[] = []; + const forEachChildTable: ForEachChildFunction[] = []; const forEachChildNoOpFn: ForEachChildFunction = (_node, _cbNode, _cbNodes) => undefined; for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(forEachChildNoOpFn); forEachChildTable[SyntaxKind.QualifiedName] = forEachChildInQualifiedName; @@ -1088,7 +1088,7 @@ namespace ts { return; } - return forEachChildTable[node.kind]?.(node, cbNode, cbNodes); + return forEachChildTable[node.kind](node, cbNode, cbNodes); } /** @internal */ From b94b82a8963b67ac8d6f436dfed5bc242f015057 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 9 Aug 2022 22:06:21 +0000 Subject: [PATCH 8/9] Grab function directly to avoid possible `.call` overhead from downlevel emit. --- src/compiler/parser.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 5df3b91b96b31..3f2934fdfed04 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -97,9 +97,8 @@ namespace ts { type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - const forEachChildTable: ForEachChildFunction[] = []; - const forEachChildNoOpFn: ForEachChildFunction = (_node, _cbNode, _cbNodes) => undefined; - for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(forEachChildNoOpFn); + const forEachChildTable: (ForEachChildFunction | undefined)[] = []; + for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(undefined); forEachChildTable[SyntaxKind.QualifiedName] = forEachChildInQualifiedName; forEachChildTable[SyntaxKind.TypeParameter] = forEachChildInTypeParameter; forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachChildInShorthandPropertyAssignment; @@ -1088,7 +1087,8 @@ namespace ts { return; } - return forEachChildTable[node.kind](node, cbNode, cbNodes); + const fn = forEachChildTable[node.kind]; + return fn === undefined ? undefined : fn(node, cbNode, cbNodes); } /** @internal */ From e9d86d92b8c2baf665067d4b0994c632abb01b75 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 9 Aug 2022 16:27:03 -0700 Subject: [PATCH 9/9] Full switch but still using functions for comparison --- src/compiler/parser.ts | 345 ++++++++++++++++++++--------------------- 1 file changed, 170 insertions(+), 175 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 3f2934fdfed04..540929cc6b569 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -95,179 +95,6 @@ namespace ts { return isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword && node.name.escapedText === "meta"; } - type ForEachChildFunction = (node: any, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined) => T | undefined; - - const forEachChildTable: (ForEachChildFunction | undefined)[] = []; - for (let i = 0; i < SyntaxKind.Count; i++) forEachChildTable.push(undefined); - forEachChildTable[SyntaxKind.QualifiedName] = forEachChildInQualifiedName; - forEachChildTable[SyntaxKind.TypeParameter] = forEachChildInTypeParameter; - forEachChildTable[SyntaxKind.ShorthandPropertyAssignment] = forEachChildInShorthandPropertyAssignment; - forEachChildTable[SyntaxKind.SpreadAssignment] = forEachChildInSpreadAssignment; - forEachChildTable[SyntaxKind.Parameter] = forEachChildInParameter; - forEachChildTable[SyntaxKind.PropertyDeclaration] = forEachChildInPropertyDeclaration; - forEachChildTable[SyntaxKind.PropertySignature] = forEachChildInPropertySignature; - forEachChildTable[SyntaxKind.PropertyAssignment] = forEachChildInPropertyAssignment; - forEachChildTable[SyntaxKind.VariableDeclaration] = forEachChildInVariableDeclaration; - forEachChildTable[SyntaxKind.BindingElement] = forEachChildInBindingElement; - forEachChildTable[SyntaxKind.IndexSignature] = forEachChildInIndexSignature; - forEachChildTable[SyntaxKind.ConstructorType] = forEachChildInConstructorType; - forEachChildTable[SyntaxKind.FunctionType] = forEachChildInFunctionType; - forEachChildTable[SyntaxKind.CallSignature] = forEachChildInCallOrConstructSignature; - forEachChildTable[SyntaxKind.ConstructSignature] = forEachChildInCallOrConstructSignature; - forEachChildTable[SyntaxKind.MethodDeclaration] = forEachChildInMethodDeclaration; - forEachChildTable[SyntaxKind.MethodSignature] = forEachChildInMethodSignature; - forEachChildTable[SyntaxKind.Constructor] = forEachChildInConstructor; - forEachChildTable[SyntaxKind.GetAccessor] = forEachChildInGetAccessor; - forEachChildTable[SyntaxKind.SetAccessor] = forEachChildInSetAccessor; - forEachChildTable[SyntaxKind.FunctionDeclaration] = forEachChildInFunctionDeclaration; - forEachChildTable[SyntaxKind.FunctionExpression] = forEachChildInFunctionExpression; - forEachChildTable[SyntaxKind.ArrowFunction] = forEachChildInArrowFunction; - forEachChildTable[SyntaxKind.ClassStaticBlockDeclaration] = forEachChildInClassStaticBlockDeclaration; - forEachChildTable[SyntaxKind.TypeReference] = forEachChildInTypeReference; - forEachChildTable[SyntaxKind.TypePredicate] = forEachChildInTypePredicate; - forEachChildTable[SyntaxKind.TypeQuery] = forEachChildInTypeQuery; - forEachChildTable[SyntaxKind.TypeLiteral] = forEachChildInTypeLiteral; - forEachChildTable[SyntaxKind.ArrayType] = forEachChildInArrayType; - forEachChildTable[SyntaxKind.TupleType] = forEachChildInTupleType; - forEachChildTable[SyntaxKind.UnionType] = forEachChildInUnionOrIntersectionType; - forEachChildTable[SyntaxKind.IntersectionType] = forEachChildInUnionOrIntersectionType; - forEachChildTable[SyntaxKind.ConditionalType] = forEachChildInConditionalType; - forEachChildTable[SyntaxKind.InferType] = forEachChildInInferType; - forEachChildTable[SyntaxKind.ImportType] = forEachChildInImportType; - forEachChildTable[SyntaxKind.ImportTypeAssertionContainer] = forEachChildInImportTypeAssertionContainer; - forEachChildTable[SyntaxKind.ParenthesizedType] = forEachChildInParenthesizedTypeOrTypeOperator; - forEachChildTable[SyntaxKind.TypeOperator] = forEachChildInParenthesizedTypeOrTypeOperator; - forEachChildTable[SyntaxKind.IndexedAccessType] = forEachChildInIndexedAccessType; - forEachChildTable[SyntaxKind.MappedType] = forEachChildInMappedType; - forEachChildTable[SyntaxKind.LiteralType] = forEachChildInLiteralType; - forEachChildTable[SyntaxKind.NamedTupleMember] = forEachChildInNamedTupleMember; - forEachChildTable[SyntaxKind.ObjectBindingPattern] = forEachChildInObjectOrArrayBindingPattern; - forEachChildTable[SyntaxKind.ArrayBindingPattern] = forEachChildInObjectOrArrayBindingPattern; - forEachChildTable[SyntaxKind.ArrayLiteralExpression] = forEachChildInArrayLiteralExpression; - forEachChildTable[SyntaxKind.ObjectLiteralExpression] = forEachChildInObjectLiteralExpression; - forEachChildTable[SyntaxKind.PropertyAccessExpression] = forEachChildInPropertyAccessExpression; - forEachChildTable[SyntaxKind.ElementAccessExpression] = forEachChildInElementAccessExpression; - forEachChildTable[SyntaxKind.CallExpression] = forEachChildInCallExpression; - forEachChildTable[SyntaxKind.NewExpression] = forEachChildInCallExpression; - forEachChildTable[SyntaxKind.TaggedTemplateExpression] = forEachChildInTaggedTemplateExpression; - forEachChildTable[SyntaxKind.TypeAssertionExpression] = forEachChildInTypeAssertionExpression; - forEachChildTable[SyntaxKind.ParenthesizedExpression] = forEachChildInParenthesizedExpression; - forEachChildTable[SyntaxKind.DeleteExpression] = forEachChildInDeleteExpression; - forEachChildTable[SyntaxKind.TypeOfExpression] = forEachChildInTypeOfExpression; - forEachChildTable[SyntaxKind.VoidExpression] = forEachChildInVoidExpression; - forEachChildTable[SyntaxKind.PrefixUnaryExpression] = forEachChildInPrefixUnaryExpression; - forEachChildTable[SyntaxKind.YieldExpression] = forEachChildInYieldExpression; - forEachChildTable[SyntaxKind.AwaitExpression] = forEachChildInAwaitExpression; - forEachChildTable[SyntaxKind.PostfixUnaryExpression] = forEachChildInPostfixUnaryExpression; - forEachChildTable[SyntaxKind.BinaryExpression] = forEachChildInBinaryExpression; - forEachChildTable[SyntaxKind.AsExpression] = forEachChildInAsExpression; - forEachChildTable[SyntaxKind.NonNullExpression] = forEachChildInNonNullExpression; - forEachChildTable[SyntaxKind.MetaProperty] = forEachChildInMetaProperty; - forEachChildTable[SyntaxKind.ConditionalExpression] = forEachChildInConditionalExpression; - forEachChildTable[SyntaxKind.SpreadElement] = forEachChildInSpreadElement; - forEachChildTable[SyntaxKind.Block] = forEachChildInBlock; - forEachChildTable[SyntaxKind.ModuleBlock] = forEachChildInBlock; - forEachChildTable[SyntaxKind.SourceFile] = forEachChildInSourceFile; - forEachChildTable[SyntaxKind.VariableStatement] = forEachChildInVariableStatement; - forEachChildTable[SyntaxKind.VariableDeclarationList] = forEachChildInVariableDeclarationList; - forEachChildTable[SyntaxKind.ExpressionStatement] = forEachChildInExpressionStatement; - forEachChildTable[SyntaxKind.IfStatement] = forEachChildInIfStatement; - forEachChildTable[SyntaxKind.DoStatement] = forEachChildInDoStatement; - forEachChildTable[SyntaxKind.WhileStatement] = forEachChildInWhileStatement; - forEachChildTable[SyntaxKind.ForStatement] = forEachChildInForStatement; - forEachChildTable[SyntaxKind.ForInStatement] = forEachChildInForInStatement; - forEachChildTable[SyntaxKind.ForOfStatement] = forEachChildInForOfStatement; - forEachChildTable[SyntaxKind.ContinueStatement] = forEachChildInContinueStatement; - forEachChildTable[SyntaxKind.BreakStatement] = forEachChildInContinueStatement; - forEachChildTable[SyntaxKind.ReturnStatement] = forEachChildInReturnStatement; - forEachChildTable[SyntaxKind.WithStatement] = forEachChildInWithStatement; - forEachChildTable[SyntaxKind.SwitchStatement] = forEachChildInSwitchStatement; - forEachChildTable[SyntaxKind.CaseBlock] = forEachChildInCaseBlock; - forEachChildTable[SyntaxKind.CaseClause] = forEachChildInCaseClause; - forEachChildTable[SyntaxKind.DefaultClause] = forEachChildInDefaultClause; - forEachChildTable[SyntaxKind.LabeledStatement] = forEachChildInLabeledStatement; - forEachChildTable[SyntaxKind.ThrowStatement] = forEachChildInThrowStatement; - forEachChildTable[SyntaxKind.TryStatement] = forEachChildInTryStatement; - forEachChildTable[SyntaxKind.CatchClause] = forEachChildInCatchClause; - forEachChildTable[SyntaxKind.Decorator] = forEachChildInDecorator; - forEachChildTable[SyntaxKind.ClassDeclaration] = forEachChildInClassDeclarationOrExpression; - forEachChildTable[SyntaxKind.ClassExpression] = forEachChildInClassDeclarationOrExpression; - forEachChildTable[SyntaxKind.InterfaceDeclaration] = forEachChildInInterfaceDeclaration; - forEachChildTable[SyntaxKind.TypeAliasDeclaration] = forEachChildInTypeAliasDeclaration; - forEachChildTable[SyntaxKind.EnumDeclaration] = forEachChildInEnumDeclaration; - forEachChildTable[SyntaxKind.EnumMember] = forEachChildInEnumMember; - forEachChildTable[SyntaxKind.ModuleDeclaration] = forEachChildInModuleDeclaration; - forEachChildTable[SyntaxKind.ImportEqualsDeclaration] = forEachChildInImportEqualsDeclaration; - forEachChildTable[SyntaxKind.ImportDeclaration] = forEachChildInImportDeclaration; - forEachChildTable[SyntaxKind.ImportClause] = forEachChildInImportClause; - forEachChildTable[SyntaxKind.AssertClause] = forEachChildInAssertClause; - forEachChildTable[SyntaxKind.AssertEntry] = forEachChildInAssertEntry; - forEachChildTable[SyntaxKind.NamespaceExportDeclaration] = forEachChildInNamespaceExportDeclaration; - forEachChildTable[SyntaxKind.NamespaceImport] = forEachChildInNamespaceImport; - forEachChildTable[SyntaxKind.NamespaceExport] = forEachChildInNamespaceExport; - forEachChildTable[SyntaxKind.NamedImports] = forEachChildInNamedImportsOrExports; - forEachChildTable[SyntaxKind.NamedExports] = forEachChildInNamedImportsOrExports; - forEachChildTable[SyntaxKind.ExportDeclaration] = forEachChildInExportDeclaration; - forEachChildTable[SyntaxKind.ImportSpecifier] = forEachChildInImportOrExportSpecifier; - forEachChildTable[SyntaxKind.ExportSpecifier] = forEachChildInImportOrExportSpecifier; - forEachChildTable[SyntaxKind.ExportAssignment] = forEachChildInExportAssignment; - forEachChildTable[SyntaxKind.TemplateExpression] = forEachChildInTemplateExpression; - forEachChildTable[SyntaxKind.TemplateSpan] = forEachChildInTemplateSpan; - forEachChildTable[SyntaxKind.TemplateLiteralType] = forEachChildInTemplateLiteralType; - forEachChildTable[SyntaxKind.TemplateLiteralTypeSpan] = forEachChildInTemplateLiteralTypeSpan; - forEachChildTable[SyntaxKind.ComputedPropertyName] = forEachChildInComputedPropertyName; - forEachChildTable[SyntaxKind.HeritageClause] = forEachChildInHeritageClause; - forEachChildTable[SyntaxKind.ExpressionWithTypeArguments] = forEachChildInExpressionWithTypeArguments; - forEachChildTable[SyntaxKind.ExternalModuleReference] = forEachChildInExternalModuleReference; - forEachChildTable[SyntaxKind.MissingDeclaration] = forEachChildInMissingDeclaration; - forEachChildTable[SyntaxKind.CommaListExpression] = forEachChildInCommaListExpression; - forEachChildTable[SyntaxKind.JsxElement] = forEachChildInJsxElement; - forEachChildTable[SyntaxKind.JsxFragment] = forEachChildInJsxFragment; - forEachChildTable[SyntaxKind.JsxSelfClosingElement] = forEachChildInJsxOpeningOrSelfClosingElement; - forEachChildTable[SyntaxKind.JsxOpeningElement] = forEachChildInJsxOpeningOrSelfClosingElement; - forEachChildTable[SyntaxKind.JsxAttributes] = forEachChildInJsxAttributes; - forEachChildTable[SyntaxKind.JsxAttribute] = forEachChildInJsxAttribute; - forEachChildTable[SyntaxKind.JsxSpreadAttribute] = forEachChildInJsxSpreadAttribute; - forEachChildTable[SyntaxKind.JsxExpression] = forEachChildInJsxExpression; - forEachChildTable[SyntaxKind.JsxClosingElement] = forEachChildInJsxClosingElement; - forEachChildTable[SyntaxKind.OptionalType] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.RestType] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocTypeExpression] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocNonNullableType] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocNullableType] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocOptionalType] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocVariadicType] = forEachChildInOptionalRestOrJSDocParameterModifier; - forEachChildTable[SyntaxKind.JSDocFunctionType] = forEachChildInJSDocFunctionType; - forEachChildTable[SyntaxKind.JSDoc] = forEachChildInJSDoc; - forEachChildTable[SyntaxKind.JSDocSeeTag] = forEachChildInJSDocSeeTag; - forEachChildTable[SyntaxKind.JSDocNameReference] = forEachChildInJSDocNameReference; - forEachChildTable[SyntaxKind.JSDocMemberName] = forEachChildInJSDocMemberName; - forEachChildTable[SyntaxKind.JSDocParameterTag] = forEachChildInJSDocParameterOrPropertyTag; - forEachChildTable[SyntaxKind.JSDocPropertyTag] = forEachChildInJSDocParameterOrPropertyTag; - forEachChildTable[SyntaxKind.JSDocAuthorTag] = forEachChildInJSDocAuthorTag; - forEachChildTable[SyntaxKind.JSDocImplementsTag] = forEachChildInJSDocImplementsTag; - forEachChildTable[SyntaxKind.JSDocAugmentsTag] = forEachChildInJSDocAugmentsTag; - forEachChildTable[SyntaxKind.JSDocTemplateTag] = forEachChildInJSDocTemplateTag; - forEachChildTable[SyntaxKind.JSDocTypedefTag] = forEachChildInJSDocTypedefTag; - forEachChildTable[SyntaxKind.JSDocCallbackTag] = forEachChildInJSDocCallbackTag; - forEachChildTable[SyntaxKind.JSDocReturnTag] = forEachChildInJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocTypeTag] = forEachChildInJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocThisTag] = forEachChildInJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocEnumTag] = forEachChildInJSDocReturnTag; - forEachChildTable[SyntaxKind.JSDocSignature] = forEachChildInJSDocSignature; - forEachChildTable[SyntaxKind.JSDocLink] = forEachChildInJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocLinkCode] = forEachChildInJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocLinkPlain] = forEachChildInJSDocLinkCodeOrPlain; - forEachChildTable[SyntaxKind.JSDocTypeLiteral] = forEachChildInJSDocTypeLiteral; - forEachChildTable[SyntaxKind.JSDocTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.JSDocClassTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.JSDocPublicTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.JSDocPrivateTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.JSDocProtectedTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.JSDocReadonlyTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.JSDocDeprecatedTag] = forEachChildInJSDocTag; - forEachChildTable[SyntaxKind.PartiallyEmittedExpression] = forEachChildInPartiallyEmittedExpression; - function forEachChildInQualifiedName(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined { return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); @@ -1087,8 +914,176 @@ namespace ts { return; } - const fn = forEachChildTable[node.kind]; - return fn === undefined ? undefined : fn(node, cbNode, cbNodes); + switch(node.kind) { + case SyntaxKind.QualifiedName: return forEachChildInQualifiedName(node as any, cbNode, cbNodes); + case SyntaxKind.TypeParameter: return forEachChildInTypeParameter(node as any, cbNode, cbNodes); + case SyntaxKind.ShorthandPropertyAssignment: return forEachChildInShorthandPropertyAssignment(node as any, cbNode, cbNodes); + case SyntaxKind.SpreadAssignment: return forEachChildInSpreadAssignment(node as any, cbNode, cbNodes); + case SyntaxKind.Parameter: return forEachChildInParameter(node as any, cbNode, cbNodes); + case SyntaxKind.PropertyDeclaration: return forEachChildInPropertyDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.PropertySignature: return forEachChildInPropertySignature(node as any, cbNode, cbNodes); + case SyntaxKind.PropertyAssignment: return forEachChildInPropertyAssignment(node as any, cbNode, cbNodes); + case SyntaxKind.VariableDeclaration: return forEachChildInVariableDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.BindingElement: return forEachChildInBindingElement(node as any, cbNode, cbNodes); + case SyntaxKind.IndexSignature: return forEachChildInIndexSignature(node as any, cbNode, cbNodes); + case SyntaxKind.ConstructorType: return forEachChildInConstructorType(node as any, cbNode, cbNodes); + case SyntaxKind.FunctionType: return forEachChildInFunctionType(node as any, cbNode, cbNodes); + case SyntaxKind.CallSignature: return forEachChildInCallOrConstructSignature(node as any, cbNode, cbNodes); + case SyntaxKind.ConstructSignature: return forEachChildInCallOrConstructSignature(node as any, cbNode, cbNodes); + case SyntaxKind.MethodDeclaration: return forEachChildInMethodDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.MethodSignature: return forEachChildInMethodSignature(node as any, cbNode, cbNodes); + case SyntaxKind.Constructor: return forEachChildInConstructor(node as any, cbNode, cbNodes); + case SyntaxKind.GetAccessor: return forEachChildInGetAccessor(node as any, cbNode, cbNodes); + case SyntaxKind.SetAccessor: return forEachChildInSetAccessor(node as any, cbNode, cbNodes); + case SyntaxKind.FunctionDeclaration: return forEachChildInFunctionDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.FunctionExpression: return forEachChildInFunctionExpression(node as any, cbNode, cbNodes); + case SyntaxKind.ArrowFunction: return forEachChildInArrowFunction(node as any, cbNode, cbNodes); + case SyntaxKind.ClassStaticBlockDeclaration: return forEachChildInClassStaticBlockDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.TypeReference: return forEachChildInTypeReference(node as any, cbNode, cbNodes); + case SyntaxKind.TypePredicate: return forEachChildInTypePredicate(node as any, cbNode, cbNodes); + case SyntaxKind.TypeQuery: return forEachChildInTypeQuery(node as any, cbNode, cbNodes); + case SyntaxKind.TypeLiteral: return forEachChildInTypeLiteral(node as any, cbNode, cbNodes); + case SyntaxKind.ArrayType: return forEachChildInArrayType(node as any, cbNode, cbNodes); + case SyntaxKind.TupleType: return forEachChildInTupleType(node as any, cbNode, cbNodes); + case SyntaxKind.UnionType: return forEachChildInUnionOrIntersectionType(node as any, cbNode, cbNodes); + case SyntaxKind.IntersectionType: return forEachChildInUnionOrIntersectionType(node as any, cbNode, cbNodes); + case SyntaxKind.ConditionalType: return forEachChildInConditionalType(node as any, cbNode, cbNodes); + case SyntaxKind.InferType: return forEachChildInInferType(node as any, cbNode, cbNodes); + case SyntaxKind.ImportType: return forEachChildInImportType(node as any, cbNode, cbNodes); + case SyntaxKind.ImportTypeAssertionContainer: return forEachChildInImportTypeAssertionContainer(node as any, cbNode, cbNodes); + case SyntaxKind.ParenthesizedType: return forEachChildInParenthesizedTypeOrTypeOperator(node as any, cbNode, cbNodes); + case SyntaxKind.TypeOperator: return forEachChildInParenthesizedTypeOrTypeOperator(node as any, cbNode, cbNodes); + case SyntaxKind.IndexedAccessType: return forEachChildInIndexedAccessType(node as any, cbNode, cbNodes); + case SyntaxKind.MappedType: return forEachChildInMappedType(node as any, cbNode, cbNodes); + case SyntaxKind.LiteralType: return forEachChildInLiteralType(node as any, cbNode, cbNodes); + case SyntaxKind.NamedTupleMember: return forEachChildInNamedTupleMember(node as any, cbNode, cbNodes); + case SyntaxKind.ObjectBindingPattern: return forEachChildInObjectOrArrayBindingPattern(node as any, cbNode, cbNodes); + case SyntaxKind.ArrayBindingPattern: return forEachChildInObjectOrArrayBindingPattern(node as any, cbNode, cbNodes); + case SyntaxKind.ArrayLiteralExpression: return forEachChildInArrayLiteralExpression(node as any, cbNode, cbNodes); + case SyntaxKind.ObjectLiteralExpression: return forEachChildInObjectLiteralExpression(node as any, cbNode, cbNodes); + case SyntaxKind.PropertyAccessExpression: return forEachChildInPropertyAccessExpression(node as any, cbNode, cbNodes); + case SyntaxKind.ElementAccessExpression: return forEachChildInElementAccessExpression(node as any, cbNode, cbNodes); + case SyntaxKind.CallExpression: return forEachChildInCallExpression(node as any, cbNode, cbNodes); + case SyntaxKind.NewExpression: return forEachChildInCallExpression(node as any, cbNode, cbNodes); + case SyntaxKind.TaggedTemplateExpression: return forEachChildInTaggedTemplateExpression(node as any, cbNode, cbNodes); + case SyntaxKind.TypeAssertionExpression: return forEachChildInTypeAssertionExpression(node as any, cbNode, cbNodes); + case SyntaxKind.ParenthesizedExpression: return forEachChildInParenthesizedExpression(node as any, cbNode, cbNodes); + case SyntaxKind.DeleteExpression: return forEachChildInDeleteExpression(node as any, cbNode, cbNodes); + case SyntaxKind.TypeOfExpression: return forEachChildInTypeOfExpression(node as any, cbNode, cbNodes); + case SyntaxKind.VoidExpression: return forEachChildInVoidExpression(node as any, cbNode, cbNodes); + case SyntaxKind.PrefixUnaryExpression: return forEachChildInPrefixUnaryExpression(node as any, cbNode, cbNodes); + case SyntaxKind.YieldExpression: return forEachChildInYieldExpression(node as any, cbNode, cbNodes); + case SyntaxKind.AwaitExpression: return forEachChildInAwaitExpression(node as any, cbNode, cbNodes); + case SyntaxKind.PostfixUnaryExpression: return forEachChildInPostfixUnaryExpression(node as any, cbNode, cbNodes); + case SyntaxKind.BinaryExpression: return forEachChildInBinaryExpression(node as any, cbNode, cbNodes); + case SyntaxKind.AsExpression: return forEachChildInAsExpression(node as any, cbNode, cbNodes); + case SyntaxKind.NonNullExpression: return forEachChildInNonNullExpression(node as any, cbNode, cbNodes); + case SyntaxKind.MetaProperty: return forEachChildInMetaProperty(node as any, cbNode, cbNodes); + case SyntaxKind.ConditionalExpression: return forEachChildInConditionalExpression(node as any, cbNode, cbNodes); + case SyntaxKind.SpreadElement: return forEachChildInSpreadElement(node as any, cbNode, cbNodes); + case SyntaxKind.Block: return forEachChildInBlock(node as any, cbNode, cbNodes); + case SyntaxKind.ModuleBlock: return forEachChildInBlock(node as any, cbNode, cbNodes); + case SyntaxKind.SourceFile: return forEachChildInSourceFile(node as any, cbNode, cbNodes); + case SyntaxKind.VariableStatement: return forEachChildInVariableStatement(node as any, cbNode, cbNodes); + case SyntaxKind.VariableDeclarationList: return forEachChildInVariableDeclarationList(node as any, cbNode, cbNodes); + case SyntaxKind.ExpressionStatement: return forEachChildInExpressionStatement(node as any, cbNode, cbNodes); + case SyntaxKind.IfStatement: return forEachChildInIfStatement(node as any, cbNode, cbNodes); + case SyntaxKind.DoStatement: return forEachChildInDoStatement(node as any, cbNode, cbNodes); + case SyntaxKind.WhileStatement: return forEachChildInWhileStatement(node as any, cbNode, cbNodes); + case SyntaxKind.ForStatement: return forEachChildInForStatement(node as any, cbNode, cbNodes); + case SyntaxKind.ForInStatement: return forEachChildInForInStatement(node as any, cbNode, cbNodes); + case SyntaxKind.ForOfStatement: return forEachChildInForOfStatement(node as any, cbNode, cbNodes); + case SyntaxKind.ContinueStatement: return forEachChildInContinueStatement(node as any, cbNode, cbNodes); + case SyntaxKind.BreakStatement: return forEachChildInContinueStatement(node as any, cbNode, cbNodes); + case SyntaxKind.ReturnStatement: return forEachChildInReturnStatement(node as any, cbNode, cbNodes); + case SyntaxKind.WithStatement: return forEachChildInWithStatement(node as any, cbNode, cbNodes); + case SyntaxKind.SwitchStatement: return forEachChildInSwitchStatement(node as any, cbNode, cbNodes); + case SyntaxKind.CaseBlock: return forEachChildInCaseBlock(node as any, cbNode, cbNodes); + case SyntaxKind.CaseClause: return forEachChildInCaseClause(node as any, cbNode, cbNodes); + case SyntaxKind.DefaultClause: return forEachChildInDefaultClause(node as any, cbNode, cbNodes); + case SyntaxKind.LabeledStatement: return forEachChildInLabeledStatement(node as any, cbNode, cbNodes); + case SyntaxKind.ThrowStatement: return forEachChildInThrowStatement(node as any, cbNode, cbNodes); + case SyntaxKind.TryStatement: return forEachChildInTryStatement(node as any, cbNode, cbNodes); + case SyntaxKind.CatchClause: return forEachChildInCatchClause(node as any, cbNode, cbNodes); + case SyntaxKind.Decorator: return forEachChildInDecorator(node as any, cbNode, cbNodes); + case SyntaxKind.ClassDeclaration: return forEachChildInClassDeclarationOrExpression(node as any, cbNode, cbNodes); + case SyntaxKind.ClassExpression: return forEachChildInClassDeclarationOrExpression(node as any, cbNode, cbNodes); + case SyntaxKind.InterfaceDeclaration: return forEachChildInInterfaceDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.TypeAliasDeclaration: return forEachChildInTypeAliasDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.EnumDeclaration: return forEachChildInEnumDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.EnumMember: return forEachChildInEnumMember(node as any, cbNode, cbNodes); + case SyntaxKind.ModuleDeclaration: return forEachChildInModuleDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.ImportEqualsDeclaration: return forEachChildInImportEqualsDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.ImportDeclaration: return forEachChildInImportDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.ImportClause: return forEachChildInImportClause(node as any, cbNode, cbNodes); + case SyntaxKind.AssertClause: return forEachChildInAssertClause(node as any, cbNode, cbNodes); + case SyntaxKind.AssertEntry: return forEachChildInAssertEntry(node as any, cbNode, cbNodes); + case SyntaxKind.NamespaceExportDeclaration: return forEachChildInNamespaceExportDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.NamespaceImport: return forEachChildInNamespaceImport(node as any, cbNode, cbNodes); + case SyntaxKind.NamespaceExport: return forEachChildInNamespaceExport(node as any, cbNode, cbNodes); + case SyntaxKind.NamedImports: return forEachChildInNamedImportsOrExports(node as any, cbNode, cbNodes); + case SyntaxKind.NamedExports: return forEachChildInNamedImportsOrExports(node as any, cbNode, cbNodes); + case SyntaxKind.ExportDeclaration: return forEachChildInExportDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.ImportSpecifier: return forEachChildInImportOrExportSpecifier(node as any, cbNode, cbNodes); + case SyntaxKind.ExportSpecifier: return forEachChildInImportOrExportSpecifier(node as any, cbNode, cbNodes); + case SyntaxKind.ExportAssignment: return forEachChildInExportAssignment(node as any, cbNode, cbNodes); + case SyntaxKind.TemplateExpression: return forEachChildInTemplateExpression(node as any, cbNode, cbNodes); + case SyntaxKind.TemplateSpan: return forEachChildInTemplateSpan(node as any, cbNode, cbNodes); + case SyntaxKind.TemplateLiteralType: return forEachChildInTemplateLiteralType(node as any, cbNode, cbNodes); + case SyntaxKind.TemplateLiteralTypeSpan: return forEachChildInTemplateLiteralTypeSpan(node as any, cbNode, cbNodes); + case SyntaxKind.ComputedPropertyName: return forEachChildInComputedPropertyName(node as any, cbNode, cbNodes); + case SyntaxKind.HeritageClause: return forEachChildInHeritageClause(node as any, cbNode, cbNodes); + case SyntaxKind.ExpressionWithTypeArguments: return forEachChildInExpressionWithTypeArguments(node as any, cbNode, cbNodes); + case SyntaxKind.ExternalModuleReference: return forEachChildInExternalModuleReference(node as any, cbNode, cbNodes); + case SyntaxKind.MissingDeclaration: return forEachChildInMissingDeclaration(node as any, cbNode, cbNodes); + case SyntaxKind.CommaListExpression: return forEachChildInCommaListExpression(node as any, cbNode, cbNodes); + case SyntaxKind.JsxElement: return forEachChildInJsxElement(node as any, cbNode, cbNodes); + case SyntaxKind.JsxFragment: return forEachChildInJsxFragment(node as any, cbNode, cbNodes); + case SyntaxKind.JsxSelfClosingElement: return forEachChildInJsxOpeningOrSelfClosingElement(node as any, cbNode, cbNodes); + case SyntaxKind.JsxOpeningElement: return forEachChildInJsxOpeningOrSelfClosingElement(node as any, cbNode, cbNodes); + case SyntaxKind.JsxAttributes: return forEachChildInJsxAttributes(node as any, cbNode, cbNodes); + case SyntaxKind.JsxAttribute: return forEachChildInJsxAttribute(node as any, cbNode, cbNodes); + case SyntaxKind.JsxSpreadAttribute: return forEachChildInJsxSpreadAttribute(node as any, cbNode, cbNodes); + case SyntaxKind.JsxExpression: return forEachChildInJsxExpression(node as any, cbNode, cbNodes); + case SyntaxKind.JsxClosingElement: return forEachChildInJsxClosingElement(node as any, cbNode, cbNodes); + case SyntaxKind.OptionalType: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.RestType: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocTypeExpression: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocNonNullableType: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocNullableType: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocOptionalType: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocVariadicType: return forEachChildInOptionalRestOrJSDocParameterModifier(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocFunctionType: return forEachChildInJSDocFunctionType(node as any, cbNode, cbNodes); + case SyntaxKind.JSDoc: return forEachChildInJSDoc(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocSeeTag: return forEachChildInJSDocSeeTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocNameReference: return forEachChildInJSDocNameReference(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocMemberName: return forEachChildInJSDocMemberName(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocParameterTag: return forEachChildInJSDocParameterOrPropertyTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocPropertyTag: return forEachChildInJSDocParameterOrPropertyTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocAuthorTag: return forEachChildInJSDocAuthorTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocImplementsTag: return forEachChildInJSDocImplementsTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocAugmentsTag: return forEachChildInJSDocAugmentsTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocTemplateTag: return forEachChildInJSDocTemplateTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocTypedefTag: return forEachChildInJSDocTypedefTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocCallbackTag: return forEachChildInJSDocCallbackTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocReturnTag: return forEachChildInJSDocReturnTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocTypeTag: return forEachChildInJSDocReturnTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocThisTag: return forEachChildInJSDocReturnTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocEnumTag: return forEachChildInJSDocReturnTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocSignature: return forEachChildInJSDocSignature(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocLink: return forEachChildInJSDocLinkCodeOrPlain(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocLinkCode: return forEachChildInJSDocLinkCodeOrPlain(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocLinkPlain: return forEachChildInJSDocLinkCodeOrPlain(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocTypeLiteral: return forEachChildInJSDocTypeLiteral(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocClassTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocPublicTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocPrivateTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocProtectedTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocReadonlyTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.JSDocDeprecatedTag: return forEachChildInJSDocTag(node as any, cbNode, cbNodes); + case SyntaxKind.PartiallyEmittedExpression: return forEachChildInPartiallyEmittedExpression(node as any, cbNode, cbNodes); + } } /** @internal */