Renames in servermode per feedback (#39883)

sheetalkamat · web-flow · commit da5ff57608dd · 2020-08-05T12:19:15.000-07:00
* Server mode renames as per feedback

* More renames
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -719,10 +719,10 @@ namespace ts.server {
             this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(getDirectoryPath(this.getExecutingFilePath()), "typesMap.json") : opts.typesMapLocation;
             if (opts.serverMode !== undefined) {
                 this.serverMode = opts.serverMode;
-                this.syntaxOnly = this.serverMode === LanguageServiceMode.SyntaxOnly;
+                this.syntaxOnly = this.serverMode === LanguageServiceMode.Syntactic;
             }
             else if (opts.syntaxOnly) {
-                this.serverMode = LanguageServiceMode.SyntaxOnly;
+                this.serverMode = LanguageServiceMode.Syntactic;
                 this.syntaxOnly = true;
             }
             else {
@@ -3029,7 +3029,7 @@ namespace ts.server {
             let retainProjects: ConfiguredProject[] | ConfiguredProject | undefined;
             let projectForConfigFileDiag: ConfiguredProject | undefined;
             let defaultConfigProjectIsCreated = false;
-            if (this.serverMode === LanguageServiceMode.ApproximateSemanticOnly) {
+            if (this.serverMode === LanguageServiceMode.PartialSemantic) {
                 // Invalidate resolutions in the file since this file is now open
                 info.containingProjects.forEach(project => {
                     if (project.resolutionCache.removeRelativeNoResolveResolutionsOfFile(info.path)) {
@@ -3124,7 +3124,7 @@ namespace ts.server {
                 Debug.assert(this.openFiles.has(info.path));
                 this.assignOrphanScriptInfoToInferredProject(info, this.openFiles.get(info.path));
             }
-            else if (this.serverMode === LanguageServiceMode.ApproximateSemanticOnly && info.cacheSourceFile?.sourceFile.referencedFiles.length) {
+            else if (this.serverMode === LanguageServiceMode.PartialSemantic && info.cacheSourceFile?.sourceFile.referencedFiles.length) {
                 // This file was just opened and references in this file will previously not been resolved so schedule update
                 info.containingProjects.forEach(project => project.markAsDirty());
             }
diff --git a/src/server/project.ts b/src/server/project.ts
@@ -283,11 +283,11 @@ namespace ts.server {
                 case LanguageServiceMode.Semantic:
                     this.languageServiceEnabled = true;
                     break;
-                case LanguageServiceMode.ApproximateSemanticOnly:
+                case LanguageServiceMode.PartialSemantic:
                     this.languageServiceEnabled = true;
                     this.compilerOptions.types = [];
                     break;
-                case LanguageServiceMode.SyntaxOnly:
+                case LanguageServiceMode.Syntactic:
                     this.languageServiceEnabled = false;
                     this.compilerOptions.noResolve = true;
                     this.compilerOptions.types = [];
@@ -471,9 +471,9 @@ namespace ts.server {
             switch (this.projectService.serverMode) {
                 case LanguageServiceMode.Semantic:
                     return true;
-                case LanguageServiceMode.ApproximateSemanticOnly:
+                case LanguageServiceMode.PartialSemantic:
                     return this.fileIsOpen(this.toPath(containingFile));
-                case LanguageServiceMode.SyntaxOnly:
+                case LanguageServiceMode.Syntactic:
                     return false;
                 default:
                     Debug.assertNever(this.projectService.serverMode);
@@ -677,7 +677,7 @@ namespace ts.server {
         }
 
         enableLanguageService() {
-            if (this.languageServiceEnabled || this.projectService.serverMode === LanguageServiceMode.SyntaxOnly) {
+            if (this.languageServiceEnabled || this.projectService.serverMode === LanguageServiceMode.Syntactic) {
                 return;
             }
             this.languageServiceEnabled = true;
@@ -689,7 +689,7 @@ namespace ts.server {
             if (!this.languageServiceEnabled) {
                 return;
             }
-            Debug.assert(this.projectService.serverMode !== LanguageServiceMode.SyntaxOnly);
+            Debug.assert(this.projectService.serverMode !== LanguageServiceMode.Syntactic);
             this.languageService.cleanupSemanticCache();
             this.languageServiceEnabled = false;
             this.lastFileExceededProgramSize = lastFileExceededProgramSize;
diff --git a/src/server/session.ts b/src/server/session.ts
@@ -585,7 +585,7 @@ namespace ts.server {
             undefined;
     }
 
-    const invalidApproximateSemanticOnlyCommands: readonly CommandNames[] = [
+    const invalidPartialSemanticModeCommands: readonly CommandNames[] = [
         CommandNames.OpenExternalProject,
         CommandNames.OpenExternalProjects,
         CommandNames.CloseExternalProject,
@@ -621,8 +621,8 @@ namespace ts.server {
         CommandNames.ProvideCallHierarchyOutgoingCalls,
     ];
 
-    const invalidSyntaxOnlyCommands: readonly CommandNames[] = [
-        ...invalidApproximateSemanticOnlyCommands,
+    const invalidSyntacticModeCommands: readonly CommandNames[] = [
+        ...invalidPartialSemanticModeCommands,
         CommandNames.Definition,
         CommandNames.DefinitionFull,
         CommandNames.DefinitionAndBoundSpan,
@@ -751,17 +751,17 @@ namespace ts.server {
             switch (this.projectService.serverMode) {
                 case LanguageServiceMode.Semantic:
                     break;
-                case LanguageServiceMode.ApproximateSemanticOnly:
-                    invalidApproximateSemanticOnlyCommands.forEach(commandName =>
+                case LanguageServiceMode.PartialSemantic:
+                    invalidPartialSemanticModeCommands.forEach(commandName =>
                         this.handlers.set(commandName, request => {
-                            throw new Error(`Request: ${request.command} not allowed on approximate semantic only server`);
+                            throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.PartialSemantic`);
                         })
                     );
                     break;
-                case LanguageServiceMode.SyntaxOnly:
-                    invalidSyntaxOnlyCommands.forEach(commandName =>
+                case LanguageServiceMode.Syntactic:
+                    invalidSyntacticModeCommands.forEach(commandName =>
                         this.handlers.set(commandName, request => {
-                            throw new Error(`Request: ${request.command} not allowed on syntax only server`);
+                            throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.Syntactic`);
                         })
                     );
                     break;
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -1171,7 +1171,7 @@ namespace ts {
         }
     }
 
-    const invalidOperationsOnApproximateSemanticOnly: readonly (keyof LanguageService)[] = [
+    const invalidOperationsInPartialSemanticMode: readonly (keyof LanguageService)[] = [
         "getSyntacticDiagnostics",
         "getSemanticDiagnostics",
         "getSuggestionDiagnostics",
@@ -1191,8 +1191,8 @@ namespace ts {
         "provideCallHierarchyOutgoingCalls",
     ];
 
-    const invalidOperationsOnSyntaxOnly: readonly (keyof LanguageService)[] = [
-        ...invalidOperationsOnApproximateSemanticOnly,
+    const invalidOperationsInSyntacticMode: readonly (keyof LanguageService)[] = [
+        ...invalidOperationsInPartialSemanticMode,
         "getCompletionsAtPosition",
         "getCompletionEntryDetails",
         "getCompletionEntrySymbol",
@@ -1222,7 +1222,7 @@ namespace ts {
         }
         else if (typeof syntaxOnlyOrLanguageServiceMode === "boolean") {
             // languageServiceMode = SyntaxOnly
-            languageServiceMode = syntaxOnlyOrLanguageServiceMode ? LanguageServiceMode.SyntaxOnly : LanguageServiceMode.Semantic;
+            languageServiceMode = syntaxOnlyOrLanguageServiceMode ? LanguageServiceMode.Syntactic : LanguageServiceMode.Semantic;
         }
         else {
             languageServiceMode = syntaxOnlyOrLanguageServiceMode;
@@ -1276,7 +1276,7 @@ namespace ts {
         }
 
         function synchronizeHostData(): void {
-            Debug.assert(languageServiceMode !== LanguageServiceMode.SyntaxOnly);
+            Debug.assert(languageServiceMode !== LanguageServiceMode.Syntactic);
             // perform fast check if host supports it
             if (host.getProjectVersion) {
                 const hostProjectVersion = host.getProjectVersion();
@@ -1462,7 +1462,7 @@ namespace ts {
 
         // TODO: GH#18217 frequently asserted as defined
         function getProgram(): Program | undefined {
-            if (languageServiceMode === LanguageServiceMode.SyntaxOnly) {
+            if (languageServiceMode === LanguageServiceMode.Syntactic) {
                 Debug.assert(program === undefined);
                 return undefined;
             }
@@ -2545,17 +2545,17 @@ namespace ts {
         switch (languageServiceMode) {
             case LanguageServiceMode.Semantic:
                 break;
-            case LanguageServiceMode.ApproximateSemanticOnly:
-                invalidOperationsOnApproximateSemanticOnly.forEach(key =>
+            case LanguageServiceMode.PartialSemantic:
+                invalidOperationsInPartialSemanticMode.forEach(key =>
                     ls[key] = () => {
-                        throw new Error(`LanguageService Operation: ${key} not allowed on approximate semantic only server`);
+                        throw new Error(`LanguageService Operation: ${key} not allowed in LanguageServiceMode.PartialSemantic`);
                     }
                 );
                 break;
-            case LanguageServiceMode.SyntaxOnly:
-                invalidOperationsOnSyntaxOnly.forEach(key =>
+            case LanguageServiceMode.Syntactic:
+                invalidOperationsInSyntacticMode.forEach(key =>
                     ls[key] = () => {
-                        throw new Error(`LanguageService Operation: ${key} not allowed on syntax only server`);
+                        throw new Error(`LanguageService Operation: ${key} not allowed in LanguageServiceMode.Syntactic`);
                     }
                 );
                 break;
diff --git a/src/services/types.ts b/src/services/types.ts
@@ -223,8 +223,8 @@ namespace ts {
 
     export enum LanguageServiceMode {
         Semantic,
-        ApproximateSemanticOnly,
-        SyntaxOnly,
+        PartialSemantic,
+        Syntactic,
     }
 
     //
diff --git a/src/testRunner/tsconfig.json b/src/testRunner/tsconfig.json
@@ -145,7 +145,6 @@
         "unittests/tscWatch/watchApi.ts",
         "unittests/tscWatch/watchEnvironment.ts",
         "unittests/tsserver/applyChangesToOpenFiles.ts",
-        "unittests/tsserver/approximateSemanticOnlyServer.ts",
         "unittests/tsserver/autoImportProvider.ts",
         "unittests/tsserver/cachingFileSystemInformation.ts",
         "unittests/tsserver/cancellationToken.ts",
@@ -177,6 +176,7 @@
         "unittests/tsserver/occurences.ts",
         "unittests/tsserver/openFile.ts",
         "unittests/tsserver/packageJsonInfo.ts",
+        "unittests/tsserver/partialSemanticServer.ts",
         "unittests/tsserver/projectErrors.ts",
         "unittests/tsserver/projectReferenceCompileOnSave.ts",
         "unittests/tsserver/projectReferenceErrors.ts",
@@ -186,11 +186,11 @@
         "unittests/tsserver/reload.ts",
         "unittests/tsserver/rename.ts",
         "unittests/tsserver/resolutionCache.ts",
-        "unittests/tsserver/semanticOperationsOnSyntaxServer.ts",
-        "unittests/tsserver/smartSelection.ts",
         "unittests/tsserver/session.ts",
         "unittests/tsserver/skipLibCheck.ts",
+        "unittests/tsserver/smartSelection.ts",
         "unittests/tsserver/symLinks.ts",
+        "unittests/tsserver/syntacticServer.ts",
         "unittests/tsserver/syntaxOperations.ts",
         "unittests/tsserver/textStorage.ts",
         "unittests/tsserver/telemetry.ts",
diff --git a/src/testRunner/unittests/tsserver/partialSemanticServer.ts b/src/testRunner/unittests/tsserver/partialSemanticServer.ts
@@ -26,7 +26,7 @@ import { something } from "something";
                 content: "{}"
             };
             const host = createServerHost([file1, file2, file3, something, libFile, configFile]);
-            const session = createSession(host, { serverMode: LanguageServiceMode.ApproximateSemanticOnly, useSingleInferredProject: true });
+            const session = createSession(host, { serverMode: LanguageServiceMode.PartialSemantic, useSingleInferredProject: true });
             return { host, session, file1, file2, file3, something, configFile };
         }
 
@@ -138,7 +138,7 @@ import { something } from "something";
                 session.executeCommand(request);
             }
             catch (e) {
-                assert.equal(e.message, `Request: semanticDiagnosticsSync not allowed on approximate semantic only server`);
+                assert.equal(e.message, `Request: semanticDiagnosticsSync not allowed in LanguageServiceMode.PartialSemantic`);
                 hasException = true;
             }
             assert.isTrue(hasException);
@@ -149,7 +149,7 @@ import { something } from "something";
                 project.getLanguageService().getSemanticDiagnostics(file1.path);
             }
             catch (e) {
-                assert.equal(e.message, `LanguageService Operation: getSemanticDiagnostics not allowed on approximate semantic only server`);
+                assert.equal(e.message, `LanguageService Operation: getSemanticDiagnostics not allowed in LanguageServiceMode.PartialSemantic`);
                 hasException = true;
             }
             assert.isTrue(hasException);
@@ -195,7 +195,7 @@ function fooB() { }`
                 content: "{}"
             };
             const host = createServerHost([file1, file2, file3, something, libFile, configFile]);
-            const session = createSession(host, { serverMode: LanguageServiceMode.ApproximateSemanticOnly, useSingleInferredProject: true });
+            const session = createSession(host, { serverMode: LanguageServiceMode.PartialSemantic, useSingleInferredProject: true });
             const service = session.getProjectService();
             openFilesForSession([file1], session);
             checkNumberOfProjects(service, { inferredProjects: 1 });
diff --git a/src/testRunner/unittests/tsserver/syntacticServer.ts b/src/testRunner/unittests/tsserver/syntacticServer.ts
@@ -36,7 +36,7 @@ import { something } from "something";
                 session.executeCommandSeq(request);
             }
             catch (e) {
-                assert.equal(e.message, `Request: ${request.command} not allowed on syntax only server`);
+                assert.equal(e.message, `Request: ${request.command} not allowed in LanguageServiceMode.Syntactic`);
                 hasException = true;
             }
             assert.isTrue(hasException);
@@ -119,7 +119,7 @@ import { something } from "something";
                 project.getLanguageService().getSemanticDiagnostics(file1.path);
             }
             catch (e) {
-                assert.equal(e.message, `LanguageService Operation: getSemanticDiagnostics not allowed on syntax only server`);
+                assert.equal(e.message, `LanguageService Operation: getSemanticDiagnostics not allowed in LanguageServiceMode.Syntactic`);
                 hasException = true;
             }
             assert.isTrue(hasException);
diff --git a/src/tsserver/server.ts b/src/tsserver/server.ts
@@ -959,10 +959,10 @@ namespace ts.server {
         switch (mode.toLowerCase()) {
             case "semantic":
                 return LanguageServiceMode.Semantic;
-            case "approximatesemanticonly":
-                return LanguageServiceMode.ApproximateSemanticOnly;
-            case "syntaxonly":
-                return LanguageServiceMode.SyntaxOnly;
+            case "partialsemantic":
+                return LanguageServiceMode.PartialSemantic;
+            case "syntactic":
+                return LanguageServiceMode.Syntactic;
             default:
                 unknownServerMode = mode;
                 return undefined;
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -5316,8 +5316,8 @@ declare namespace ts {
     }
     enum LanguageServiceMode {
         Semantic = 0,
-        ApproximateSemanticOnly = 1,
-        SyntaxOnly = 2
+        PartialSemantic = 1,
+        Syntactic = 2
     }
     interface LanguageServiceHost extends GetEffectiveTypeRootsHost {
         getCompilationSettings(): CompilerOptions;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -5316,8 +5316,8 @@ declare namespace ts {
     }
     enum LanguageServiceMode {
         Semantic = 0,
-        ApproximateSemanticOnly = 1,
-        SyntaxOnly = 2
+        PartialSemantic = 1,
+        Syntactic = 2
     }
     interface LanguageServiceHost extends GetEffectiveTypeRootsHost {
         getCompilationSettings(): CompilerOptions;

Original file line number	Diff line number	Diff line change
`@@ -223,8 +223,8 @@ namespace ts {`
`223`	`223`
`224`	`224`	`export enum LanguageServiceMode {`
`225`	`225`	`Semantic,`
`226`		`- ApproximateSemanticOnly,`
`227`		`- SyntaxOnly,`
	`226`	`+ PartialSemantic,`
	`227`	`+ Syntactic,`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`//`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ import { something } from "something";`
`36`	`36`	`session.executeCommandSeq(request);`
`37`	`37`	`}`
`38`	`38`	`catch (e) {`
`39`		- assert.equal(e.message, `Request: ${request.command} not allowed on syntax only server`);
	`39`	+ assert.equal(e.message, `Request: ${request.command} not allowed in LanguageServiceMode.Syntactic`);
`40`	`40`	`hasException = true;`
`41`	`41`	`}`
`42`	`42`	`assert.isTrue(hasException);`
`@@ -119,7 +119,7 @@ import { something } from "something";`
`119`	`119`	`project.getLanguageService().getSemanticDiagnostics(file1.path);`
`120`	`120`	`}`
`121`	`121`	`catch (e) {`
`122`		- assert.equal(e.message, `LanguageService Operation: getSemanticDiagnostics not allowed on syntax only server`);
	`122`	+ assert.equal(e.message, `LanguageService Operation: getSemanticDiagnostics not allowed in LanguageServiceMode.Syntactic`);
`123`	`123`	`hasException = true;`
`124`	`124`	`}`
`125`	`125`	`assert.isTrue(hasException);`
Original file line number	Diff line number	Diff line change
`@@ -5316,8 +5316,8 @@ declare namespace ts {`
`5316`	`5316`	`}`
`5317`	`5317`	`enum LanguageServiceMode {`
`5318`	`5318`	`Semantic = 0,`
`5319`		`- ApproximateSemanticOnly = 1,`
`5320`		`- SyntaxOnly = 2`
	`5319`	`+ PartialSemantic = 1,`
	`5320`	`+ Syntactic = 2`
`5321`	`5321`	`}`
`5322`	`5322`	`interface LanguageServiceHost extends GetEffectiveTypeRootsHost {`
`5323`	`5323`	`getCompilationSettings(): CompilerOptions;`