Merge pull request #11603 from zhengbli/11116

Set maxNodeModuleJsDepth for inferred projects

Author: zhengbli

src/harness/unittests/tsserverProjectSystem.ts

@@ -1620,7 +1620,7 @@ namespace ts.projectSystem {
             const configureHostRequest = makeSessionRequest<protocol.ConfigureRequestArguments>(CommandNames.Configure, { extraFileExtensions });
             session.executeCommand(configureHostRequest).response;
 
-             // HTML file still not included in the project as it is closed
+            // HTML file still not included in the project as it is closed
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
             checkProjectActualFiles(projectService.configuredProjects[0], [file1.path]);
 
@@ -3051,4 +3051,59 @@ namespace ts.projectSystem {
             service.checkNumberOfProjects({ externalProjects: 1 });
         });
     });
+
+    describe("maxNodeModuleJsDepth for inferred projects", () => {
+        it("should be set to 2 if the project has js root files", () => {
+            const file1: FileOrFolder = {
+                path: "/a/b/file1.js",
+                content: `var t = require("test"); t.`
+            };
+            const moduleFile: FileOrFolder = {
+                path: "/a/b/node_modules/test/index.js",
+                content: `var v = 10; module.exports = v;`
+            };
+
+            const host = createServerHost([file1, moduleFile]);
+            const projectService = createProjectService(host);
+            projectService.openClientFile(file1.path);
+
+            let project = projectService.inferredProjects[0];
+            let options = project.getCompilerOptions();
+            assert.isTrue(options.maxNodeModuleJsDepth === 2);
+
+            // Assert the option sticks 
+            projectService.setCompilerOptionsForInferredProjects({ target: ScriptTarget.ES2016 });
+            project = projectService.inferredProjects[0];
+            options = project.getCompilerOptions();
+            assert.isTrue(options.maxNodeModuleJsDepth === 2);
+        });
+
+        it("should return to normal state when all js root files are removed from project", () => {
+            const file1 = {
+                path: "/a/file1.ts",
+                content: "let x =1;"
+            };
+            const file2 = {
+                path: "/a/file2.js",
+                content: "let x =1;"
+            };
+
+            const host = createServerHost([file1, file2, libFile]);
+            const projectService = createProjectService(host, { useSingleInferredProject: true });
+
+            projectService.openClientFile(file1.path);
+            checkNumberOfInferredProjects(projectService, 1);
+            let project = projectService.inferredProjects[0];
+            assert.isUndefined(project.getCompilerOptions().maxNodeModuleJsDepth);
+
+            projectService.openClientFile(file2.path);
+            project = projectService.inferredProjects[0];
+            assert.isTrue(project.getCompilerOptions().maxNodeModuleJsDepth === 2);
+
+            projectService.closeClientFile(file2.path);
+            project = projectService.inferredProjects[0];
+            assert.isUndefined(project.getCompilerOptions().maxNodeModuleJsDepth);
+        });
+    });
+
 }

src/server/project.ts

@@ -396,7 +396,9 @@ namespace ts.server {
         }
 
         removeFile(info: ScriptInfo, detachFromProject = true) {
-            this.removeRootFileIfNecessary(info);
+            if (this.isRoot(info)) {
+                this.removeRoot(info);
+            }
             this.lsHost.notifyFileRemoved(info);
             this.cachedUnresolvedImportsPerFile.remove(info.path);
 
@@ -567,9 +569,6 @@ namespace ts.server {
 
         setCompilerOptions(compilerOptions: CompilerOptions) {
             if (compilerOptions) {
-                if (this.projectKind === ProjectKind.Inferred) {
-                    compilerOptions.allowJs = true;
-                }
                 compilerOptions.allowNonTsExtensions = true;
                 if (changesAffectModuleResolution(this.compilerOptions, compilerOptions)) {
                     // reset cached unresolved imports if changes in compiler options affected module resolution
@@ -698,11 +697,9 @@ namespace ts.server {
         }
 
         // remove a root file from project
-        private removeRootFileIfNecessary(info: ScriptInfo): void {
-            if (this.isRoot(info)) {
-                remove(this.rootFiles, info);
-                this.rootFilesMap.remove(info.path);
-            }
+        protected removeRoot(info: ScriptInfo): void {
+            remove(this.rootFiles, info);
+            this.rootFilesMap.remove(info.path);
         }
     }
 
@@ -717,6 +714,32 @@ namespace ts.server {
             }
         })();
 
+        private _isJsInferredProject = false;
+
+        toggleJsInferredProject(isJsInferredProject: boolean) {
+            if (isJsInferredProject !== this._isJsInferredProject) {
+                this._isJsInferredProject = isJsInferredProject;
+                this.setCompilerOptions();
+            }
+        }
+
+        setCompilerOptions(options?: CompilerOptions) {
+            // Avoid manipulating the given options directly
+            const newOptions = options ? clone(options) : this.getCompilerOptions();
+            if (!newOptions) {
+                return;
+            }
+
+            if (this._isJsInferredProject && typeof newOptions.maxNodeModuleJsDepth !== "number") {
+                newOptions.maxNodeModuleJsDepth = 2;
+            }
+            else if (!this._isJsInferredProject) {
+                newOptions.maxNodeModuleJsDepth = undefined;
+            }
+            newOptions.allowJs = true;
+            super.setCompilerOptions(newOptions);
+        }
+
         // Used to keep track of what directories are watched for this project
         directoriesWatchedForTsconfig: string[] = [];
 
@@ -731,6 +754,22 @@ namespace ts.server {
                 /*compileOnSaveEnabled*/ false);
         }
 
+        addRoot(info: ScriptInfo) {
+            if (!this._isJsInferredProject && info.isJavaScript()) {
+                this.toggleJsInferredProject(/*isJsInferredProject*/ true);
+            }
+            super.addRoot(info);
+        }
+
+        removeRoot(info: ScriptInfo) {
+            if (this._isJsInferredProject && info.isJavaScript()) {
+                if (filter(this.getRootScriptInfos(), info => info.isJavaScript()).length === 0) {
+                    this.toggleJsInferredProject(/*isJsInferredProject*/ false);
+                }
+            }
+            super.removeRoot(info);
+        }
+
         getProjectRootPath() {
             // Single inferred project does not have a project root.
             if (this.projectService.useSingleInferredProject) {

src/server/scriptInfo.ts

@@ -355,5 +355,9 @@ namespace ts.server {
         positionToLineOffset(position: number): ILineInfo {
             return this.textStorage.positionToLineOffset(position);
         }
+
+        public isJavaScript() {
+            return this.scriptKind === ScriptKind.JS || this.scriptKind === ScriptKind.JSX;
+        }
     }
 }