Return non-JsDocComment children

... to make syntactic classification work

Author: zhengbli

src/services/services.ts

@@ -21,6 +21,7 @@ namespace ts {
         getChildCount(sourceFile?: SourceFile): number;
         getChildAt(index: number, sourceFile?: SourceFile): Node;
         getChildren(sourceFile?: SourceFile): Node[];
+        getNonJsDocCommentChildren?(sourceFile?: SourceFile): Node[];
         getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
         getFullStart(): number;
         getEnd(): number;
@@ -196,6 +197,7 @@ namespace ts {
         public parent: Node;
         public jsDocComments: JSDocComment[];
         private _children: Node[];
+        private _nonJsDocCommentChildren: Node[];
 
         constructor(kind: SyntaxKind, pos: number, end: number) {
             this.pos = pos;
@@ -273,20 +275,22 @@ namespace ts {
         }
 
         private createChildren(sourceFile?: SourceFile) {
-            let children: Node[];
+            let jsDocCommentChildren: Node[];
+            let nonJsDocCommentChildren: Node[];
             if (this.kind >= SyntaxKind.FirstNode) {
                 scanner.setText((sourceFile || this.getSourceFile()).text);
-                children = [];
+                jsDocCommentChildren = [];
+                nonJsDocCommentChildren = [];
                 let pos = this.pos;
                 const useJSDocScanner = this.kind >= SyntaxKind.FirstJSDocTagNode && this.kind <= SyntaxKind.LastJSDocTagNode;
-                const processNode = (node: Node) => {
+                const processNode = (node: Node, children = nonJsDocCommentChildren) => {
                     if (pos < node.pos) {
                         pos = this.addSyntheticNodes(children, pos, node.pos, useJSDocScanner);
                     }
                     children.push(node);
                     pos = node.end;
                 };
-                const processNodes = (nodes: NodeArray<Node>) => {
+                const processNodes = (nodes: NodeArray<Node>, children = nonJsDocCommentChildren) => {
                     if (pos < nodes.pos) {
                         pos = this.addSyntheticNodes(children, pos, nodes.pos, useJSDocScanner);
                     }
@@ -296,16 +300,21 @@ namespace ts {
                 // jsDocComments need to be the first children
                 if (this.jsDocComments) {
                     for (const jsDocComment of this.jsDocComments) {
-                        processNode(jsDocComment);
+                        processNode(jsDocComment, jsDocCommentChildren);
                     }
                 }
+                // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
+                // Restoring the scanner position ensures that. 
+                pos = this.pos;
                 forEachChild(this, processNode, processNodes);
                 if (pos < this.end) {
-                    this.addSyntheticNodes(children, pos, this.end);
+                    this.addSyntheticNodes(nonJsDocCommentChildren, pos, this.end);
                 }
                 scanner.setText(undefined);
             }
-            this._children = children || emptyArray;
+            this._nonJsDocCommentChildren = nonJsDocCommentChildren || emptyArray;
+            this._children = concatenate(jsDocCommentChildren, this._nonJsDocCommentChildren);
         }
 
         public getChildCount(sourceFile?: SourceFile): number {
@@ -323,6 +332,18 @@ namespace ts {
             return this._children;
         }
 
+        public getNonJsDocCommentChildren(sourceFile?: SourceFile): Node[] {
+            // If the cached children were cleared, that means some node before the current node has changed.
+            // so even if we have a cached nonJsDocCommentChildren, it would be outdated as well.
+            if (!this._children) {
+                this.createChildren(sourceFile);
+            }
+            // If the node has cached children but not nonJsDocCommentChildren, it means the children is not created
+            // via calling the "createChildren" method, so it can only be a SyntaxList. As SyntaxList cannot have jsDocCommentChildren
+            // anyways, we can just return its children.
+            return this._nonJsDocCommentChildren ? this._nonJsDocCommentChildren : this._children;
+        }
+
         public getFirstToken(sourceFile?: SourceFile): Node {
             const children = this.getChildren(sourceFile);
             if (!children.length) {
@@ -7725,7 +7746,7 @@ namespace ts {
                 if (decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) {
                     checkForClassificationCancellation(element.kind);
 
-                    const children = element.getChildren(sourceFile);
+                    const children = element.getNonJsDocCommentChildren ? element.getNonJsDocCommentChildren(sourceFile) : element.getChildren(sourceFile);
                     for (let i = 0, n = children.length; i < n; i++) {
                         const child = children[i];
                         if (!tryClassifyNode(child)) {