Cache interface range resolution

Author: rubensworks

lib/parse/ParameterResolver.ts

@@ -1,5 +1,6 @@
 import type { TSTypeLiteral } from '@typescript-eslint/types/dist/ts-estree';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import * as LRUCache from 'lru-cache';
 import type { ClassIndex, ClassReference, ClassReferenceLoaded, InterfaceLoaded } from './ClassIndex';
 import type { ClassLoader } from './ClassLoader';
 import type { CommentLoader } from './CommentLoader';
@@ -18,11 +19,13 @@ export class ParameterResolver {
   private readonly classLoader: ClassLoader;
   private readonly commentLoader: CommentLoader;
   private readonly ignoreClasses: Record<string, boolean>;
+  private readonly cacheInterfaceRange: LRUCache<string, ParameterRangeResolved>;
 
   public constructor(args: ParameterResolverArgs) {
     this.classLoader = args.classLoader;
     this.commentLoader = args.commentLoader;
     this.ignoreClasses = args.ignoreClasses;
+    this.cacheInterfaceRange = new LRUCache(2_048);
   }
 
   /**
@@ -250,6 +253,32 @@ export class ParameterResolver {
     rootOwningClass: ClassReferenceLoaded,
     genericTypeRemappings: Record<string, ParameterRangeUnresolved>,
     getNestedFields: boolean,
+  ): Promise<ParameterRangeResolved> {
+    const cacheKey = `${interfaceName}::${(qualifiedPath || []).join('.')}::${owningClass.fileName}`;
+    let resolved = this.cacheInterfaceRange.get(cacheKey);
+    if (!resolved) {
+      resolved = await this.resolveRangeInterfaceInner(
+        interfaceName,
+        qualifiedPath,
+        genericTypeParameterInstances,
+        owningClass,
+        rootOwningClass,
+        genericTypeRemappings,
+        getNestedFields,
+      );
+      this.cacheInterfaceRange.set(cacheKey, resolved);
+    }
+    return resolved;
+  }
+
+  protected async resolveRangeInterfaceInner(
+    interfaceName: string,
+    qualifiedPath: string[] | undefined,
+    genericTypeParameterInstances: ParameterRangeUnresolved[] | undefined,
+    owningClass: ClassReferenceLoaded,
+    rootOwningClass: ClassReferenceLoaded,
+    genericTypeRemappings: Record<string, ParameterRangeUnresolved>,
+    getNestedFields: boolean,
   ): Promise<ParameterRangeResolved> {
     const classOrInterface = await this.loadClassOrInterfacesChain({
       packageName: owningClass.packageName,

test/parse/ParameterResolver.test.ts

@@ -1205,6 +1205,20 @@ class ClassA {}
         });
     });
 
+    it('should resolve a class multiple times via cache', async() => {
+      resolutionContext.contentsOverrides = {
+        'A.d.ts': `
+class ClassA {}
+`,
+      };
+      const first = await loader
+        .resolveRangeInterface('ClassA', undefined, undefined, classReference, classReference, {}, true);
+      const second = await loader
+        .resolveRangeInterface('ClassA', undefined, undefined, classReference, classReference, {}, true);
+      expect(first).toBe(second);
+      expect((<any> loader).cacheInterfaceRange.keys()).toEqual([ 'ClassA::::A' ]);
+    });
+
     it('should resolve an implicit class', async() => {
       resolutionContext.contentsOverrides = {
         'A.d.ts': `