Remove unnecessary 'ts.' qualifications (#17163)

Andy · web-flow · commit d2ec45f35467 · 2017-07-13T13:08:59.000-07:00
diff --git a/src/server/client.ts b/src/server/client.ts
@@ -227,7 +227,7 @@ namespace ts.server {
             }));
         }
 
-        getFormattingEditsForRange(file: string, start: number, end: number, _options: ts.FormatCodeOptions): ts.TextChange[] {
+        getFormattingEditsForRange(file: string, start: number, end: number, _options: FormatCodeOptions): ts.TextChange[] {
             const args: protocol.FormatRequestArgs = this.createFileLocationRequestArgsWithEndLineAndOffset(file, start, end);
 
 
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -45,7 +45,7 @@ namespace ts.server {
          * Any compiler options that might contain paths will be taken out.
          * Enum compiler options will be converted to strings.
          */
-        readonly compilerOptions: ts.CompilerOptions;
+        readonly compilerOptions: CompilerOptions;
         // "extends", "files", "include", or "exclude" will be undefined if an external config is used.
         // Otherwise, we will use "true" if the property is present and "false" if it is missing.
         readonly extends: boolean | undefined;
@@ -201,7 +201,7 @@ namespace ts.server {
      * This helper function processes a list of projects and return the concatenated, sortd and deduplicated output of processing each project.
      */
     export function combineProjectOutput<T>(projects: Project[], action: (project: Project) => T[], comparer?: (a: T, b: T) => number, areEqual?: (a: T, b: T) => boolean) {
-        const result = ts.flatMap(projects, action).sort(comparer);
+        const result = flatMap(projects, action).sort(comparer);
         return projects.length > 1 ? deduplicate(result, areEqual) : result;
     }
 
@@ -240,7 +240,7 @@ namespace ts.server {
         getFileName: x => x,
         getScriptKind: _ => undefined,
         hasMixedContent: (fileName, extraFileExtensions) => {
-            const mixedContentExtensions = ts.map(ts.filter(extraFileExtensions, item => item.isMixedContent), item => item.extension);
+            const mixedContentExtensions = map(filter(extraFileExtensions, item => item.isMixedContent), item => item.extension);
             return forEach(mixedContentExtensions, extension => fileExtensionIs(fileName, extension));
         }
     };
@@ -633,7 +633,7 @@ namespace ts.server {
             // If a change was made inside "folder/file", node will trigger the callback twice:
             // one with the fileName being "folder/file", and the other one with "folder".
             // We don't respond to the second one.
-            if (fileName && !ts.isSupportedSourceFileName(fileName, project.getCompilerOptions(), this.hostConfiguration.extraFileExtensions)) {
+            if (fileName && !isSupportedSourceFileName(fileName, project.getCompilerOptions(), this.hostConfiguration.extraFileExtensions)) {
                 return;
             }
 
@@ -1082,7 +1082,7 @@ namespace ts.server {
                 configFileName: configFileName(),
                 projectType: project instanceof server.ExternalProject ? "external" : "configured",
                 languageServiceEnabled: project.languageServiceEnabled,
-                version: ts.version,
+                version,
             };
             this.eventHandler({ eventName: ProjectInfoTelemetryEvent, data });
 
@@ -1092,7 +1092,7 @@ namespace ts.server {
                 }
 
                 const configFilePath = project instanceof server.ConfiguredProject && project.getConfigFilePath();
-                const base = ts.getBaseFileName(configFilePath);
+                const base = getBaseFileName(configFilePath);
                 return base === "tsconfig.json" || base === "jsconfig.json" ? base : "other";
             }
 
diff --git a/src/server/lsHost.ts b/src/server/lsHost.ts
@@ -3,8 +3,8 @@
 /// <reference path="scriptInfo.ts" />
 
 namespace ts.server {
-    export class LSHost implements ts.LanguageServiceHost, ModuleResolutionHost {
-        private compilationSettings: ts.CompilerOptions;
+    export class LSHost implements LanguageServiceHost, ModuleResolutionHost {
+        private compilationSettings: CompilerOptions;
         private readonly resolvedModuleNames = createMap<Map<ResolvedModuleWithFailedLookupLocations>>();
         private readonly resolvedTypeReferenceDirectives = createMap<Map<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
         private readonly getCanonicalFileName: (fileName: string) => string;
@@ -17,7 +17,7 @@ namespace ts.server {
 
         constructor(private readonly host: ServerHost, private project: Project, private readonly cancellationToken: HostCancellationToken) {
             this.cancellationToken = new ThrottledCancellationToken(cancellationToken, project.projectService.throttleWaitMilliseconds);
-            this.getCanonicalFileName = ts.createGetCanonicalFileName(this.host.useCaseSensitiveFileNames);
+            this.getCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames);
 
             if (host.trace) {
                 this.trace = s => host.trace(s);
@@ -99,7 +99,7 @@ namespace ts.server {
                     }
                 }
 
-                ts.Debug.assert(resolution !== undefined);
+                Debug.assert(resolution !== undefined);
 
                 resolvedModules.push(getResult(resolution));
             }
@@ -177,7 +177,7 @@ namespace ts.server {
             return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilationSettings));
         }
 
-        getScriptSnapshot(filename: string): ts.IScriptSnapshot {
+        getScriptSnapshot(filename: string): IScriptSnapshot {
             const scriptInfo = this.project.getScriptInfoLSHost(filename);
             if (scriptInfo) {
                 return scriptInfo.getSnapshot();
@@ -238,7 +238,7 @@ namespace ts.server {
             this.resolvedTypeReferenceDirectives.delete(info.path);
         }
 
-        setCompilationSettings(opt: ts.CompilerOptions) {
+        setCompilationSettings(opt: CompilerOptions) {
             if (changesAffectModuleResolution(this.compilationSettings, opt)) {
                 this.resolvedModuleNames.clear();
                 this.resolvedTypeReferenceDirectives.clear();
diff --git a/src/server/project.ts b/src/server/project.ts
@@ -105,7 +105,7 @@ namespace ts.server {
     export abstract class Project {
         private rootFiles: ScriptInfo[] = [];
         private rootFilesMap: Map<ScriptInfo> = createMap<ScriptInfo>();
-        private program: ts.Program;
+        private program: Program;
         private externalFiles: SortedReadonlyArray<string>;
         private missingFilesMap: Map<FileWatcher> = createMap<FileWatcher>();
 
@@ -180,14 +180,14 @@ namespace ts.server {
             private readonly projectName: string,
             readonly projectKind: ProjectKind,
             readonly projectService: ProjectService,
-            private documentRegistry: ts.DocumentRegistry,
+            private documentRegistry: DocumentRegistry,
             hasExplicitListOfFiles: boolean,
             languageServiceEnabled: boolean,
             private compilerOptions: CompilerOptions,
             public compileOnSaveEnabled: boolean) {
 
             if (!this.compilerOptions) {
-                this.compilerOptions = ts.getDefaultCompilerOptions();
+                this.compilerOptions = getDefaultCompilerOptions();
                 this.compilerOptions.allowNonTsExtensions = true;
                 this.compilerOptions.allowJs = true;
             }
@@ -201,7 +201,7 @@ namespace ts.server {
             this.lsHost = new LSHost(this.projectService.host, this, this.projectService.cancellationToken);
             this.lsHost.setCompilationSettings(this.compilerOptions);
 
-            this.languageService = ts.createLanguageService(this.lsHost, this.documentRegistry);
+            this.languageService = createLanguageService(this.lsHost, this.documentRegistry);
 
             if (!languageServiceEnabled) {
                 this.disableLanguageService();
@@ -875,7 +875,7 @@ namespace ts.server {
         // Used to keep track of what directories are watched for this project
         directoriesWatchedForTsconfig: string[] = [];
 
-        constructor(projectService: ProjectService, documentRegistry: ts.DocumentRegistry, compilerOptions: CompilerOptions) {
+        constructor(projectService: ProjectService, documentRegistry: DocumentRegistry, compilerOptions: CompilerOptions) {
             super(InferredProject.newName(),
                 ProjectKind.Inferred,
                 projectService,
@@ -948,7 +948,7 @@ namespace ts.server {
 
         constructor(configFileName: NormalizedPath,
             projectService: ProjectService,
-            documentRegistry: ts.DocumentRegistry,
+            documentRegistry: DocumentRegistry,
             hasExplicitListOfFiles: boolean,
             compilerOptions: CompilerOptions,
             private wildcardDirectories: Map<WatchDirectoryFlags>,
@@ -1152,7 +1152,7 @@ namespace ts.server {
         }
 
         getEffectiveTypeRoots() {
-            return ts.getEffectiveTypeRoots(this.getCompilerOptions(), this.projectService.host) || [];
+            return getEffectiveTypeRoots(this.getCompilerOptions(), this.projectService.host) || [];
         }
     }
 
@@ -1164,7 +1164,7 @@ namespace ts.server {
         private typeAcquisition: TypeAcquisition;
         constructor(public externalProjectName: string,
             projectService: ProjectService,
-            documentRegistry: ts.DocumentRegistry,
+            documentRegistry: DocumentRegistry,
             compilerOptions: CompilerOptions,
             languageServiceEnabled: boolean,
             public compileOnSaveEnabled: boolean,
diff --git a/src/server/scriptInfo.ts b/src/server/scriptInfo.ts
@@ -72,12 +72,12 @@ namespace ts.server {
                 const lineMap = this.getLineMap();
                 const start = lineMap[line]; // -1 since line is 1-based
                 const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
-                return ts.createTextSpanFromBounds(start, end);
+                return createTextSpanFromBounds(start, end);
             }
             const index = this.svc.getSnapshot().index;
             const { lineText, absolutePosition } = index.lineNumberToInfo(line + 1);
             const len = lineText !== undefined ? lineText.length : index.absolutePositionOfStartOfLine(line + 2) - absolutePosition;
-            return ts.createTextSpan(absolutePosition, len);
+            return createTextSpan(absolutePosition, len);
         }
 
         /**
@@ -147,7 +147,7 @@ namespace ts.server {
          * All projects that include this file
          */
         readonly containingProjects: Project[] = [];
-        private formatCodeSettings: ts.FormatCodeSettings;
+        private formatCodeSettings: FormatCodeSettings;
         readonly path: Path;
 
         private fileWatcher: FileWatcher;
diff --git a/src/server/scriptVersionCache.ts b/src/server/scriptVersionCache.ts
@@ -248,7 +248,7 @@ namespace ts.server {
         }
 
         getTextChangeRange() {
-            return ts.createTextChangeRange(ts.createTextSpan(this.pos, this.deleteLen),
+            return createTextChangeRange(createTextSpan(this.pos, this.deleteLen),
                 this.insertedText ? this.insertedText.length : 0);
         }
     }
@@ -337,21 +337,21 @@ namespace ts.server {
         getTextChangesBetweenVersions(oldVersion: number, newVersion: number) {
             if (oldVersion < newVersion) {
                 if (oldVersion >= this.minVersion) {
-                    const textChangeRanges: ts.TextChangeRange[] = [];
+                    const textChangeRanges: TextChangeRange[] = [];
                     for (let i = oldVersion + 1; i <= newVersion; i++) {
                         const snap = this.versions[this.versionToIndex(i)];
                         for (const textChange of snap.changesSincePreviousVersion) {
                             textChangeRanges.push(textChange.getTextChangeRange());
                         }
                     }
-                    return ts.collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);
+                    return collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);
                 }
                 else {
                     return undefined;
                 }
             }
             else {
-                return ts.unchangedTextChangeRange;
+                return unchangedTextChangeRange;
             }
         }
 
@@ -365,7 +365,7 @@ namespace ts.server {
         }
     }
 
-    export class LineIndexSnapshot implements ts.IScriptSnapshot {
+    export class LineIndexSnapshot implements IScriptSnapshot {
         constructor(readonly version: number, readonly cache: ScriptVersionCache, readonly index: LineIndex, readonly changesSincePreviousVersion: ReadonlyArray<TextChange> = emptyArray) {
         }
 
@@ -377,10 +377,10 @@ namespace ts.server {
             return this.index.root.charCount();
         }
 
-        getChangeRange(oldSnapshot: ts.IScriptSnapshot): ts.TextChangeRange {
+        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange {
             if (oldSnapshot instanceof LineIndexSnapshot && this.cache === oldSnapshot.cache) {
                 if (this.version <= oldSnapshot.version) {
-                    return ts.unchangedTextChangeRange;
+                    return unchangedTextChangeRange;
                 }
                 else {
                     return this.cache.getTextChangesBetweenVersions(oldSnapshot.version, this.version);
@@ -539,7 +539,7 @@ namespace ts.server {
         }
 
         static linesFromText(text: string) {
-            const lineMap = ts.computeLineStarts(text);
+            const lineMap = computeLineStarts(text);
 
             if (lineMap.length === 0) {
                 return { lines: <string[]>[], lineMap };
diff --git a/src/server/server.ts b/src/server/server.ts
@@ -138,7 +138,7 @@ namespace ts.server {
         terminal: false,
     });
 
-    class Logger implements ts.server.Logger {
+    class Logger implements server.Logger {
         private fd = -1;
         private seq = 0;
         private inGroup = false;
diff --git a/src/server/session.ts b/src/server/session.ts
diff --git a/src/server/types.ts b/src/server/types.ts
diff --git a/src/server/utilities.ts b/src/server/utilities.ts

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ namespace ts.server {`
`227`	`227`	`}));`
`228`	`228`	`}`
`229`	`229`
`230`		`- getFormattingEditsForRange(file: string, start: number, end: number, _options: ts.FormatCodeOptions): ts.TextChange[] {`
	`230`	`+ getFormattingEditsForRange(file: string, start: number, end: number, _options: FormatCodeOptions): ts.TextChange[] {`
`231`	`231`	`const args: protocol.FormatRequestArgs = this.createFileLocationRequestArgsWithEndLineAndOffset(file, start, end);`
`232`	`232`
`233`	`233`
Original file line number	Diff line number	Diff line change
`@@ -248,7 +248,7 @@ namespace ts.server {`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`getTextChangeRange() {`
`251`		`- return ts.createTextChangeRange(ts.createTextSpan(this.pos, this.deleteLen),`
	`251`	`+ return createTextChangeRange(createTextSpan(this.pos, this.deleteLen),`
`252`	`252`	`this.insertedText ? this.insertedText.length : 0);`
`253`	`253`	`}`
`254`	`254`	`}`
`@@ -337,21 +337,21 @@ namespace ts.server {`
`337`	`337`	`getTextChangesBetweenVersions(oldVersion: number, newVersion: number) {`
`338`	`338`	`if (oldVersion < newVersion) {`
`339`	`339`	`if (oldVersion >= this.minVersion) {`
`340`		`- const textChangeRanges: ts.TextChangeRange[] = [];`
	`340`	`+ const textChangeRanges: TextChangeRange[] = [];`
`341`	`341`	`for (let i = oldVersion + 1; i <= newVersion; i++) {`
`342`	`342`	`const snap = this.versions[this.versionToIndex(i)];`
`343`	`343`	`for (const textChange of snap.changesSincePreviousVersion) {`
`344`	`344`	`textChangeRanges.push(textChange.getTextChangeRange());`
`345`	`345`	`}`
`346`	`346`	`}`
`347`		`- return ts.collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);`
	`347`	`+ return collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);`
`348`	`348`	`}`
`349`	`349`	`else {`
`350`	`350`	`return undefined;`
`351`	`351`	`}`
`352`	`352`	`}`
`353`	`353`	`else {`
`354`		`- return ts.unchangedTextChangeRange;`
	`354`	`+ return unchangedTextChangeRange;`
`355`	`355`	`}`
`356`	`356`	`}`
`357`	`357`
`@@ -365,7 +365,7 @@ namespace ts.server {`
`365`	`365`	`}`
`366`	`366`	`}`
`367`	`367`
`368`		`- export class LineIndexSnapshot implements ts.IScriptSnapshot {`
	`368`	`+ export class LineIndexSnapshot implements IScriptSnapshot {`
`369`	`369`	`constructor(readonly version: number, readonly cache: ScriptVersionCache, readonly index: LineIndex, readonly changesSincePreviousVersion: ReadonlyArray<TextChange> = emptyArray) {`
`370`	`370`	`}`
`371`	`371`
`@@ -377,10 +377,10 @@ namespace ts.server {`
`377`	`377`	`return this.index.root.charCount();`
`378`	`378`	`}`
`379`	`379`
`380`		`- getChangeRange(oldSnapshot: ts.IScriptSnapshot): ts.TextChangeRange {`
	`380`	`+ getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange {`
`381`	`381`	`if (oldSnapshot instanceof LineIndexSnapshot && this.cache === oldSnapshot.cache) {`
`382`	`382`	`if (this.version <= oldSnapshot.version) {`
`383`		`- return ts.unchangedTextChangeRange;`
	`383`	`+ return unchangedTextChangeRange;`
`384`	`384`	`}`
`385`	`385`	`else {`
`386`	`386`	`return this.cache.getTextChangesBetweenVersions(oldSnapshot.version, this.version);`
`@@ -539,7 +539,7 @@ namespace ts.server {`
`539`	`539`	`}`
`540`	`540`
`541`	`541`	`static linesFromText(text: string) {`
`542`		`- const lineMap = ts.computeLineStarts(text);`
	`542`	`+ const lineMap = computeLineStarts(text);`
`543`	`543`
`544`	`544`	`if (lineMap.length === 0) {`
`545`	`545`	`return { lines: <string[]>[], lineMap };`