introduce branded type for TypingsArray

vladima · vladima · commit 3f18fbc14529 · 2016-08-17T16:42:05.000-07:00
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -87,7 +87,7 @@ namespace ts {
         return node.end - node.pos;
     }
 
-    export function arrayIsEqualTo<T>(array1: T[], array2: T[], equaler?: (a: T, b: T) => boolean): boolean {
+    export function arrayIsEqualTo<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, equaler?: (a: T, b: T) => boolean): boolean {
         if (!array1 || !array2) {
             return array1 === array2;
         }
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -214,7 +214,6 @@ namespace ts.server {
             switch (response.kind) {
                 case "set":
                     this.typingsCache.updateTypingsForProject(response.projectName, response.compilerOptions, response.typingOptions, response.typings);
-                    project.setTypings(response.typings);
                     project.updateGraph();
                     break;
                 case "invalidate":
diff --git a/src/server/project.ts b/src/server/project.ts
@@ -47,7 +47,7 @@ namespace ts.server {
          */
         private projectStateVersion = 0;
 
-        private typingFiles: string[];
+        private typingFiles: TypingsArray;
 
         constructor(
             readonly projectKind: ProjectKind,
@@ -226,18 +226,19 @@ namespace ts.server {
             if (!this.languageServiceEnabled) {
                 return true;
             }
-            const hasChanges = this.updateGraphWorker();
+            let hasChanges = this.updateGraphWorker();
+            const cachedTypings = this.projectService.typingsCache.getTypingsForProject(this);
+            if (this.setTypings(cachedTypings)) {
+                hasChanges = this.updateGraphWorker() || hasChanges;
+            }
             if (hasChanges) {
-                if (this.setTypings(this.projectService.typingsCache.getTypingsForProject(this))) {
-                    this.updateGraphWorker();
-                }
                 this.projectStructureVersion++;
             }
             return !hasChanges;
         }
 
-        setTypings(typings: string[]): boolean {
-            if (typings === this.typingFiles) {
+        private setTypings(typings: TypingsArray): boolean {
+            if (arrayIsEqualTo(this.typingFiles, typings)) {
                 return false;
             }
             this.typingFiles = typings;
diff --git a/src/server/typingsCache.ts b/src/server/typingsCache.ts
@@ -16,7 +16,7 @@ namespace ts.server {
     class TypingsCacheEntry {
         readonly typingOptions: TypingOptions;
         readonly compilerOptions: CompilerOptions;
-        readonly typings: string[];
+        readonly typings: TypingsArray;
     }
 
     const emptyArray: any[] = [];
@@ -43,9 +43,7 @@ namespace ts.server {
         if ((arr1 || emptyArray).length === 0 && (arr2 || emptyArray).length === 0) {
             return true;
         }
-/* tslint:disable:no-null-keyword */
-        const set: Map<boolean> = Object.create(null);
-/* tslint:enable:no-null-keyword */
+        const set: Map<boolean> = createMap<boolean>();
         let unique = 0;
 
         for (const v of arr1) {
@@ -77,24 +75,33 @@ namespace ts.server {
         return opt1.allowJs != opt2.allowJs;
     }
 
+    export interface TypingsArray extends ReadonlyArray<string> {
+        " __typingsArrayBrand": any;
+    }
+
+    function toTypingsArray(arr: string[]): TypingsArray {
+        arr.sort();
+        return <any>arr;
+    }
+
     export class TypingsCache {
         private readonly perProjectCache: Map<TypingsCacheEntry> = createMap<TypingsCacheEntry>();
 
         constructor(private readonly installer: ITypingsInstaller) {
         }
 
-        getTypingsForProject(project: Project): Path[] {
+        getTypingsForProject(project: Project): TypingsArray {
             const typingOptions = getTypingOptionsForProjects(project);
 
             if (!typingOptions.enableAutoDiscovery) {
-                return emptyArray;
+                return <any>emptyArray;
             }
 
             const entry = this.perProjectCache[project.getProjectName()];
             if (!entry || typingOptionsChanged(typingOptions, entry.typingOptions) || compilerOptionsChanged(project.getCompilerOptions(), entry.compilerOptions)) {
                 this.installer.enqueueInstallTypingsRequest(project, typingOptions);
             }
-            return entry ? entry.typings : emptyArray;
+            return entry ? entry.typings : <any>emptyArray;
         }
 
         invalidateCachedTypingsForProject(project: Project) {
@@ -109,7 +116,7 @@ namespace ts.server {
             this.perProjectCache[projectName] = {
                 compilerOptions,
                 typingOptions,
-                typings: newTypings
+                typings: toTypingsArray(newTypings)
             };
         }
 

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ namespace ts {`
`87`	`87`	`return node.end - node.pos;`
`88`	`88`	`}`
`89`	`89`
`90`		`- export function arrayIsEqualTo<T>(array1: T[], array2: T[], equaler?: (a: T, b: T) => boolean): boolean {`
	`90`	`+ export function arrayIsEqualTo<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, equaler?: (a: T, b: T) => boolean): boolean {`
`91`	`91`	`if (!array1 \|\| !array2) {`
`92`	`92`	`return array1 === array2;`
`93`	`93`	`}`