diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index e30a73e093503..540929cc6b569 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -95,6 +95,807 @@ namespace ts {
         return isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword && node.name.escapedText === "meta";
     }
 
+    function forEachChildInQualifiedName<T>(node: QualifiedName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.left) ||
+            visitNode(cbNode, node.right);
+    }
+
+    function forEachChildInTypeParameter<T>(node: TypeParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.constraint) ||
+            visitNode(cbNode, node.default) ||
+            visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInShorthandPropertyAssignment<T>(node: ShorthandPropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInSpreadAssignment<T>(node: SpreadAssignment, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInParameter<T>(node: ParameterDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInPropertyDeclaration<T>(node: PropertyDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInPropertySignature<T>(node: PropertySignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.questionToken) ||
+            visitNode(cbNode, node.type) ||
+            visitNode(cbNode, node.initializer);
+    }
+
+    function forEachChildInPropertyAssignment<T>(node: PropertyAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInVariableDeclaration<T>(node: VariableDeclaration, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.exclamationToken) ||
+            visitNode(cbNode, node.type) ||
+            visitNode(cbNode, node.initializer);
+    }
+
+    function forEachChildInBindingElement<T>(node: BindingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.dotDotDotToken) ||
+            visitNode(cbNode, node.propertyName) ||
+            visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.initializer);
+    }
+
+    function forEachChildInIndexSignature<T>(node: IndexSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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 forEachChildInConstructorType<T>(node: ConstructorTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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 forEachChildInFunctionType<T>(node: FunctionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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 forEachChildInCallOrConstructSignature<T>(node: CallSignatureDeclaration | ConstructSignatureDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.typeParameters) ||
+            visitNodes(cbNode, cbNodes, node.parameters) ||
+            visitNode(cbNode, node.type);
+    }
+
+    function forEachChildInMethodDeclaration<T>(node: MethodDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInMethodSignature<T>(node: MethodSignature, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInConstructor<T>(node: ConstructorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInGetAccessor<T>(node: GetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInSetAccessor<T>(node: SetAccessorDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInFunctionDeclaration<T>(node: FunctionDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInFunctionExpression<T>(node: FunctionExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInArrowFunction<T>(node: ArrowFunction, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInClassStaticBlockDeclaration<T>(node: ClassStaticBlockDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.body);
+    }
+
+    function forEachChildInTypeReference<T>(node: TypeReferenceNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.typeName) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments);
+    }
+
+    function forEachChildInTypePredicate<T>(node: TypePredicateNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.assertsModifier) ||
+            visitNode(cbNode, node.parameterName) ||
+            visitNode(cbNode, node.type);
+    }
+
+    function forEachChildInTypeQuery<T>(node: TypeQueryNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.exprName) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments);
+    }
+
+    function forEachChildInTypeLiteral<T>(node: TypeLiteralNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.members);
+    }
+
+    function forEachChildInArrayType<T>(node: ArrayTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.elementType);
+    }
+
+    function forEachChildInTupleType<T>(node: TupleTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.elements);
+    }
+
+    function forEachChildInUnionOrIntersectionType<T>(node: UnionTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.types);
+    }
+
+    function forEachChildInConditionalType<T>(node: ConditionalTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.checkType) ||
+            visitNode(cbNode, node.extendsType) ||
+            visitNode(cbNode, node.trueType) ||
+            visitNode(cbNode, node.falseType);
+    }
+
+    function forEachChildInInferType<T>(node: InferTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.typeParameter);
+    }
+
+    function forEachChildInImportType<T>(node: ImportTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.argument) ||
+            visitNode(cbNode, node.assertions) ||
+            visitNode(cbNode, node.qualifier) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments);
+    }
+
+    function forEachChildInImportTypeAssertionContainer<T>(node: ImportTypeAssertionContainer, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.assertClause);
+    }
+
+    function forEachChildInParenthesizedTypeOrTypeOperator<T>(node: ParenthesizedTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, (node as ParenthesizedTypeNode | TypeOperatorNode).type);
+    }
+
+    function forEachChildInIndexedAccessType<T>(node: IndexedAccessTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.objectType) ||
+            visitNode(cbNode, node.indexType);
+    }
+
+    function forEachChildInMappedType<T>(node: MappedTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInLiteralType<T>(node: LiteralTypeNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.literal);
+    }
+
+    function forEachChildInNamedTupleMember<T>(node: NamedTupleMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.dotDotDotToken) ||
+            visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.questionToken) ||
+            visitNode(cbNode, node.type);
+    }
+
+    function forEachChildInObjectOrArrayBindingPattern<T>(node: ObjectBindingPattern, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.elements);
+    }
+
+    function forEachChildInArrayLiteralExpression<T>(node: ArrayLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.elements);
+    }
+
+    function forEachChildInObjectLiteralExpression<T>(node: ObjectLiteralExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.properties);
+    }
+
+    function forEachChildInPropertyAccessExpression<T>(node: PropertyAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.questionDotToken) ||
+            visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInElementAccessExpression<T>(node: ElementAccessExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.questionDotToken) ||
+            visitNode(cbNode, node.argumentExpression);
+    }
+
+    function forEachChildInCallExpression<T>(node: CallExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.questionDotToken) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments) ||
+            visitNodes(cbNode, cbNodes, node.arguments);
+    }
+
+    function forEachChildInTaggedTemplateExpression<T>(node: TaggedTemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tag) ||
+            visitNode(cbNode, node.questionDotToken) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments) ||
+            visitNode(cbNode, node.template);
+    }
+
+    function forEachChildInTypeAssertionExpression<T>(node: TypeAssertion, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.type) ||
+            visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInParenthesizedExpression<T>(node: ParenthesizedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInDeleteExpression<T>(node: DeleteExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInTypeOfExpression<T>(node: TypeOfExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInVoidExpression<T>(node: VoidExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInPrefixUnaryExpression<T>(node: PrefixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.operand);
+    }
+
+    function forEachChildInYieldExpression<T>(node: YieldExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.asteriskToken) ||
+            visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInAwaitExpression<T>(node: AwaitExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInPostfixUnaryExpression<T>(node: PostfixUnaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.operand);
+    }
+
+    function forEachChildInBinaryExpression<T>(node: BinaryExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.left) ||
+            visitNode(cbNode, node.operatorToken) ||
+            visitNode(cbNode, node.right);
+    }
+
+    function forEachChildInAsExpression<T>(node: AsExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.type);
+    }
+
+    function forEachChildInNonNullExpression<T>(node: NonNullExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInMetaProperty<T>(node: MetaProperty, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInConditionalExpression<T>(node: ConditionalExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.condition) ||
+            visitNode(cbNode, node.questionToken) ||
+            visitNode(cbNode, node.whenTrue) ||
+            visitNode(cbNode, node.colonToken) ||
+            visitNode(cbNode, node.whenFalse);
+    }
+
+    function forEachChildInSpreadElement<T>(node: SpreadElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInBlock<T>(node: Block, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.statements);
+    }
+
+    function forEachChildInSourceFile<T>(node: SourceFile, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.statements) ||
+            visitNode(cbNode, node.endOfFileToken);
+    }
+
+    function forEachChildInVariableStatement<T>(node: VariableStatement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.declarationList);
+    }
+
+    function forEachChildInVariableDeclarationList<T>(node: VariableDeclarationList, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.declarations);
+    }
+
+    function forEachChildInExpressionStatement<T>(node: ExpressionStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInIfStatement<T>(node: IfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.thenStatement) ||
+            visitNode(cbNode, node.elseStatement);
+    }
+
+    function forEachChildInDoStatement<T>(node: DoStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.statement) ||
+            visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInWhileStatement<T>(node: WhileStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.statement);
+    }
+
+    function forEachChildInForStatement<T>(node: ForStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.initializer) ||
+            visitNode(cbNode, node.condition) ||
+            visitNode(cbNode, node.incrementor) ||
+            visitNode(cbNode, node.statement);
+    }
+
+    function forEachChildInForInStatement<T>(node: ForInStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.initializer) ||
+            visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.statement);
+    }
+
+    function forEachChildInForOfStatement<T>(node: ForOfStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.awaitModifier) ||
+            visitNode(cbNode, node.initializer) ||
+            visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.statement);
+    }
+
+    function forEachChildInContinueStatement<T>(node: ContinueStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.label);
+    }
+
+    function forEachChildInReturnStatement<T>(node: ReturnStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInWithStatement<T>(node: WithStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.statement);
+    }
+
+    function forEachChildInSwitchStatement<T>(node: SwitchStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.caseBlock);
+    }
+
+    function forEachChildInCaseBlock<T>(node: CaseBlock, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.clauses);
+    }
+
+    function forEachChildInCaseClause<T>(node: CaseClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNodes(cbNode, cbNodes, node.statements);
+    }
+
+    function forEachChildInDefaultClause<T>(node: DefaultClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.statements);
+    }
+
+    function forEachChildInLabeledStatement<T>(node: LabeledStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.label) ||
+            visitNode(cbNode, node.statement);
+    }
+
+    function forEachChildInThrowStatement<T>(node: ThrowStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInTryStatement<T>(node: TryStatement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tryBlock) ||
+            visitNode(cbNode, node.catchClause) ||
+            visitNode(cbNode, node.finallyBlock);
+    }
+
+    function forEachChildInCatchClause<T>(node: CatchClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.variableDeclaration) ||
+            visitNode(cbNode, node.block);
+    }
+
+    function forEachChildInDecorator<T>(node: Decorator, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInClassDeclarationOrExpression<T>(node: ClassDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInInterfaceDeclaration<T>(node: InterfaceDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInTypeAliasDeclaration<T>(node: TypeAliasDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInEnumDeclaration<T>(node: EnumDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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 forEachChildInEnumMember<T>(node: EnumMember, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.initializer);
+    }
+
+    function forEachChildInModuleDeclaration<T>(node: ModuleDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.body);
+    }
+
+    function forEachChildInImportEqualsDeclaration<T>(node: ImportEqualsDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.moduleReference);
+    }
+
+    function forEachChildInImportDeclaration<T>(node: ImportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInImportClause<T>(node: ImportClause, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.namedBindings);
+    }
+
+    function forEachChildInAssertClause<T>(node: AssertClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.elements);
+    }
+
+    function forEachChildInAssertEntry<T>(node: AssertEntry, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.value);
+    }
+
+    function forEachChildInNamespaceExportDeclaration<T>(node: NamespaceExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInNamespaceImport<T>(node: NamespaceImport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInNamespaceExport<T>(node: NamespaceExport, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInNamedImportsOrExports<T>(node: NamedImports, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.elements);
+    }
+
+    function forEachChildInExportDeclaration<T>(node: ExportDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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);
+    }
+
+    function forEachChildInImportOrExportSpecifier<T>(node: ImportSpecifier, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.propertyName) ||
+            visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInExportAssignment<T>(node: ExportAssignment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNodes(cbNode, cbNodes, node.modifiers) ||
+            visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInTemplateExpression<T>(node: TemplateExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.head) ||
+            visitNodes(cbNode, cbNodes, node.templateSpans);
+    }
+
+    function forEachChildInTemplateSpan<T>(node: TemplateSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNode(cbNode, node.literal);
+    }
+
+    function forEachChildInTemplateLiteralType<T>(node: TemplateLiteralTypeNode, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.head) ||
+            visitNodes(cbNode, cbNodes, node.templateSpans);
+    }
+
+    function forEachChildInTemplateLiteralTypeSpan<T>(node: TemplateLiteralTypeSpan, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.type) ||
+            visitNode(cbNode, node.literal);
+    }
+
+    function forEachChildInComputedPropertyName<T>(node: ComputedPropertyName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInHeritageClause<T>(node: HeritageClause, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.types);
+    }
+
+    function forEachChildInExpressionWithTypeArguments<T>(node: ExpressionWithTypeArguments, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments);
+    }
+
+    function forEachChildInExternalModuleReference<T>(node: ExternalModuleReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInMissingDeclaration<T>(node: MissingDeclaration, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.decorators) ||
+            visitNodes(cbNode, cbNodes, node.modifiers);
+    }
+
+    function forEachChildInCommaListExpression<T>(node: CommaListExpression, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.elements);
+    }
+
+
+    function forEachChildInJsxElement<T>(node: JsxElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.openingElement) ||
+            visitNodes(cbNode, cbNodes, node.children) ||
+            visitNode(cbNode, node.closingElement);
+    }
+
+    function forEachChildInJsxFragment<T>(node: JsxFragment, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.openingFragment) ||
+            visitNodes(cbNode, cbNodes, node.children) ||
+            visitNode(cbNode, node.closingFragment);
+    }
+
+    function forEachChildInJsxOpeningOrSelfClosingElement<T>(node: JsxOpeningLikeElement, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName) ||
+            visitNodes(cbNode, cbNodes, node.typeArguments) ||
+            visitNode(cbNode, node.attributes);
+    }
+
+    function forEachChildInJsxAttributes<T>(node: JsxAttributes, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.properties);
+    }
+
+    function forEachChildInJsxAttribute<T>(node: JsxAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name) ||
+            visitNode(cbNode, node.initializer);
+    }
+
+    function forEachChildInJsxSpreadAttribute<T>(node: JsxSpreadAttribute, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInJsxExpression<T>(node: JsxExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.dotDotDotToken) ||
+            visitNode(cbNode, node.expression);
+    }
+
+    function forEachChildInJsxClosingElement<T>(node: JsxClosingElement, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName);
+    }
+
+
+    function forEachChildInOptionalRestOrJSDocParameterModifier<T>(node: OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.type);
+    }
+
+    function forEachChildInJSDocFunctionType<T>(node: JSDocFunctionType, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNodes(cbNode, cbNodes, node.parameters) ||
+            visitNode(cbNode, node.type);
+    }
+
+    function forEachChildInJSDoc<T>(node: JSDoc, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))
+            || visitNodes(cbNode, cbNodes, node.tags);
+    }
+
+    function forEachChildInJSDocSeeTag<T>(node: JSDocSeeTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName) ||
+            visitNode(cbNode, node.name) ||
+            (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+    }
+
+    function forEachChildInJSDocNameReference<T>(node: JSDocNameReference, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInJSDocMemberName<T>(node: JSDocMemberName, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.left) ||
+            visitNode(cbNode, node.right);
+    }
+
+    function forEachChildInJSDocParameterOrPropertyTag<T>(node: JSDocParameterTag | JSDocPropertyTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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)));
+    }
+
+    function forEachChildInJSDocAuthorTag<T>(node: JSDocAuthorTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName) ||
+            (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+    }
+
+    function forEachChildInJSDocImplementsTag<T>(node: JSDocImplementsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName) ||
+            visitNode(cbNode, node.class) ||
+            (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+    }
+
+    function forEachChildInJSDocAugmentsTag<T>(node: JSDocAugmentsTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName) ||
+            visitNode(cbNode, node.class) ||
+            (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+    }
+
+    function forEachChildInJSDocTemplateTag<T>(node: JSDocTemplateTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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 forEachChildInJSDocTypedefTag<T>(node: JSDocTypedefTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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)));
+    }
+
+    function forEachChildInJSDocCallbackTag<T>(node: JSDocCallbackTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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 forEachChildInJSDocReturnTag<T>(node: JSDocReturnTag | JSDocTypeTag | JSDocThisTag | JSDocEnumTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName) ||
+            visitNode(cbNode, node.typeExpression) ||
+            (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+    }
+
+    function forEachChildInJSDocSignature<T>(node: JSDocSignature, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return forEach(node.typeParameters, cbNode) ||
+            forEach(node.parameters, cbNode) ||
+            visitNode(cbNode, node.type);
+    }
+    function forEachChildInJSDocLinkCodeOrPlain<T>(node: JSDocLink | JSDocLinkCode | JSDocLinkPlain, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+            return visitNode(cbNode, node.name);
+    }
+
+    function forEachChildInJSDocTypeLiteral<T>(node: JSDocTypeLiteral, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return forEach(node.jsDocPropertyTags, cbNode);
+    }
+
+
+    function forEachChildInJSDocTag<T>(node: JSDocTag | JSDocClassTag | JSDocPublicTag | JSDocPrivateTag | JSDocProtectedTag | JSDocReadonlyTag | JSDocDeprecatedTag, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined {
+        return visitNode(cbNode, node.tagName)
+            || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+    }
+
+    function forEachChildInPartiallyEmittedExpression<T>(node: PartiallyEmittedExpression, cbNode: (node: Node) => T | undefined, _cbNodes?: (nodes: NodeArray<Node>) => T | undefined): 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,563 +910,179 @@ namespace ts {
      * that they appear in the source code. The language service depends on this property to locate nodes by position.
      */
     export function forEachChild<T>(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | 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<JSDocComment> | undefined));
-            case SyntaxKind.PartiallyEmittedExpression:
-                return visitNode(cbNode, (node as PartiallyEmittedExpression).expression);
+
+        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);
         }
     }