Fix interface range cache ignoring generic params in cache key

Author: rubensworks

lib/parse/ParameterResolver.ts

@@ -254,6 +254,33 @@ export class ParameterResolver {
     }
   }
 
+  /**
+   * Hash the given parameter range to a unique string representation.
+   * @param range An unresolved range.
+   */
+  public hashParameterRangeUnresolved(range: ParameterRangeUnresolved): string {
+    switch (range.type) {
+      case 'undefined':
+        return 'undefined';
+      case 'interface':
+      case 'genericTypeReference':
+      case 'raw':
+      case 'literal':
+      case 'override':
+        return `${range.type}:${range.value}`;
+      case 'union':
+      case 'intersection':
+      case 'tuple':
+        return `${range.type}:[${range.elements.map(element => this.hashParameterRangeUnresolved(element)).join(',')}]`;
+      case 'rest':
+      case 'array':
+      case 'keyof':
+        return `${range.type}:[${this.hashParameterRangeUnresolved(range.value)}]`;
+      case 'hash':
+        return `hash:${JSON.stringify(range.value)}`;
+    }
+  }
+
   /**
    * Resolve a class or interface.
    * @param interfaceName A class or interface name.
@@ -275,7 +302,11 @@ export class ParameterResolver {
     genericTypeRemappings: Record<string, ParameterRangeUnresolved>,
     getNestedFields: boolean,
   ): Promise<ParameterRangeResolved> {
-    const cacheKey = `${interfaceName}::${(qualifiedPath || []).join('.')}::${owningClass.fileName}`;
+    const cacheKeyGenerics = genericTypeParameterInstances ?
+      genericTypeParameterInstances.map(genericTypeParameterInstance => this
+        .hashParameterRangeUnresolved(genericTypeParameterInstance)).join(',') :
+      '';
+    const cacheKey = `${interfaceName}::${(qualifiedPath || []).join('.')}::${cacheKeyGenerics}::${owningClass.fileName}`;
     let resolved = this.cacheInterfaceRange.get(cacheKey);
     if (!resolved) {
       resolved = this.resolveRangeInterfaceInner(

test/parse/ParameterResolver.test.ts

@@ -536,6 +536,103 @@ describe('ParameterResolver', () => {
     });
   });
 
+  describe('hashParameterRangeUnresolved', () => {
+    it('should hash undefined', () => {
+      expect(loader.hashParameterRangeUnresolved({ type: 'undefined' }))
+        .toEqual('undefined');
+    });
+
+    it('should hash interface', () => {
+      expect(loader.hashParameterRangeUnresolved(<any> { type: 'interface', value: 'IFACE' }))
+        .toEqual('interface:IFACE');
+    });
+
+    it('should hash genericTypeReference', () => {
+      expect(loader.hashParameterRangeUnresolved({ type: 'genericTypeReference', value: 'val' }))
+        .toEqual('genericTypeReference:val');
+    });
+
+    it('should hash raw', () => {
+      expect(loader.hashParameterRangeUnresolved({ type: 'raw', value: 'boolean' }))
+        .toEqual('raw:boolean');
+    });
+
+    it('should hash literal', () => {
+      expect(loader.hashParameterRangeUnresolved({ type: 'literal', value: 'val' }))
+        .toEqual('literal:val');
+    });
+
+    it('should hash override', () => {
+      expect(loader.hashParameterRangeUnresolved({ type: 'override', value: 'val' }))
+        .toEqual('override:val');
+    });
+
+    it('should hash union', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'union',
+        elements: [
+          { type: 'raw', value: 'boolean' },
+          { type: 'raw', value: 'number' },
+        ],
+      }))
+        .toEqual('union:[raw:boolean,raw:number]');
+    });
+
+    it('should hash intersection', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'intersection',
+        elements: [
+          { type: 'raw', value: 'boolean' },
+          { type: 'raw', value: 'number' },
+        ],
+      }))
+        .toEqual('intersection:[raw:boolean,raw:number]');
+    });
+
+    it('should hash tuple', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'tuple',
+        elements: [
+          { type: 'raw', value: 'boolean' },
+          { type: 'raw', value: 'number' },
+        ],
+      }))
+        .toEqual('tuple:[raw:boolean,raw:number]');
+    });
+
+    it('should hash rest', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'rest',
+        value: { type: 'raw', value: 'boolean' },
+      }))
+        .toEqual('rest:[raw:boolean]');
+    });
+
+    it('should hash array', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'array',
+        value: { type: 'raw', value: 'boolean' },
+      }))
+        .toEqual('array:[raw:boolean]');
+    });
+
+    it('should hash keyof', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'keyof',
+        value: { type: 'raw', value: 'boolean' },
+      }))
+        .toEqual('keyof:[raw:boolean]');
+    });
+
+    it('should hash hash', () => {
+      expect(loader.hashParameterRangeUnresolved({
+        type: 'hash',
+        value: <any> { a: 'b' },
+      }))
+        .toEqual('hash:{"a":"b"}');
+    });
+  });
+
   describe('resolveRange', () => {
     const classReference: ClassReferenceLoaded = <any> { localName: 'A', fileName: 'A' };
 
@@ -1246,7 +1343,26 @@ class ClassA {}
       const second = await loader
         .resolveRangeInterface('ClassA', undefined, undefined, classReference, classReference, {}, true);
       expect(first).toBe(second);
-      expect((<any> loader).cacheInterfaceRange.keys()).toEqual([ 'ClassA::::A' ]);
+      expect((<any> loader).cacheInterfaceRange.keys()).toEqual([ 'ClassA::::::A' ]);
+    });
+
+    it('should resolve a class multiple times with different generics without cache', async() => {
+      resolutionContext.contentsOverrides = {
+        'A.d.ts': `
+class ClassA {}
+`,
+      };
+      const first = await loader
+        .resolveRangeInterface('ClassA', undefined, [
+          { type: 'raw', value: 'boolean' },
+        ], classReference, classReference, {}, true);
+      const second = await loader
+        .resolveRangeInterface('ClassA', undefined, [
+          { type: 'raw', value: 'number' },
+        ], classReference, classReference, {}, true);
+      expect(first).not.toBe(second);
+      expect((<any> loader).cacheInterfaceRange.keys())
+        .toEqual([ 'ClassA::::raw:number::A', 'ClassA::::raw:boolean::A' ]);
     });
 
     it('should resolve an implicit class', async() => {