Fix generics not being generated for interfaces

Author: rubensworks

lib/generate/Generator.ts

@@ -8,6 +8,7 @@ import { ClassIndexer } from '../parse/ClassIndexer';
 import { ClassLoader } from '../parse/ClassLoader';
 import { CommentLoader } from '../parse/CommentLoader';
 import { ConstructorLoader } from '../parse/ConstructorLoader';
+import { GenericsLoader } from '../parse/GenericsLoader';
 import type { PackageMetadata } from '../parse/PackageMetadataLoader';
 import { PackageMetadataLoader } from '../parse/PackageMetadataLoader';
 import { ParameterLoader } from '../parse/ParameterLoader';
@@ -82,6 +83,10 @@ export class Generator {
       const constructorsUnresolved = new ConstructorLoader({ commentLoader }).getConstructors(classAndInterfaceIndex);
       const constructors = await parameterResolver.resolveAllConstructorParameters(constructorsUnresolved);
 
+      // Load generics data
+      const genericsUnresolved = new GenericsLoader({ parameterLoader }).getGenerics(classAndInterfaceIndex);
+      const generics = await parameterResolver.resolveAllGenericTypeParameterData(genericsUnresolved);
+
       // Load extensions data
       const extensionsUnresolved = parameterLoader.loadAllExtensionData(classAndInterfaceIndex);
       const extensions = await parameterResolver.resolveAllExtensionData(extensionsUnresolved, classAndInterfaceIndex);
@@ -106,8 +111,9 @@ export class Generator {
         contextConstructor,
         pathDestination,
         classAndInterfaceIndex,
-        classExtensions: extensions,
         classConstructors: constructors,
+        classGenerics: generics,
+        classExtensions: extensions,
         externalComponents,
         contextParser: new ContextParser({
           documentLoader: new PrefetchedDocumentLoader({

lib/parse/ConstructorLoader.ts

@@ -3,7 +3,7 @@ import type { AST, TSESTreeOptions } from '@typescript-eslint/typescript-estree'
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import type { ClassIndex, ClassLoaded, ClassReferenceLoaded, GenericallyTyped } from './ClassIndex';
 import type { CommentLoader } from './CommentLoader';
-import type { GenericTypeParameterData, ParameterDataField, ParameterRangeUnresolved } from './ParameterLoader';
+import type { ParameterDataField, ParameterRangeUnresolved } from './ParameterLoader';
 import { ParameterLoader } from './ParameterLoader';
 
 /**
@@ -27,7 +27,6 @@ export class ConstructorLoader {
     for (const [ className, classLoadedRoot ] of Object.entries(classIndex)) {
       // Initialize default value
       constructorDataIndex[className] = {
-        genericTypeParameters: [],
         parameters: [],
         classLoaded: classLoadedRoot,
       };
@@ -132,7 +131,6 @@ export interface ConstructorLoaderArgs {
  * Constructor parameter information
  */
 export interface ConstructorData<R> {
-  genericTypeParameters: GenericTypeParameterData<R>[];
   parameters: ParameterDataField<R>[];
   classLoaded: ClassReferenceLoaded;
 }

lib/parse/GenericsLoader.ts

@@ -0,0 +1,45 @@
+import type { ClassIndex, ClassReferenceLoaded } from './ClassIndex';
+import type {
+  GenericTypeParameterData,
+  ParameterLoader,
+  ParameterRangeUnresolved,
+} from './ParameterLoader';
+
+/**
+ * Loads the generics data of classes.
+ */
+export class GenericsLoader {
+  private readonly parameterLoader: ParameterLoader;
+
+  public constructor(args: GenericsLoaderArgs) {
+    this.parameterLoader = args.parameterLoader;
+  }
+
+  /**
+   * Create a class index containing all generics data from the classes in the given index.
+   * @param classIndex An index of loaded classes.
+   */
+  public getGenerics(
+    classIndex: ClassIndex<ClassReferenceLoaded>,
+  ): ClassIndex<GenericsData<ParameterRangeUnresolved>> {
+    const genericsDataIndex: ClassIndex<GenericsData<ParameterRangeUnresolved>> = {};
+    for (const [ className, classLoadedRoot ] of Object.entries(classIndex)) {
+      if (classLoadedRoot.type === 'class' || classLoadedRoot.type === 'interface') {
+        genericsDataIndex[className] = this.parameterLoader.loadClassGenerics(classLoadedRoot);
+      }
+    }
+    return genericsDataIndex;
+  }
+}
+
+export interface GenericsLoaderArgs {
+  parameterLoader: ParameterLoader;
+}
+
+/**
+ * Generics parameter information
+ */
+export interface GenericsData<R> {
+  genericTypeParameters: GenericTypeParameterData<R>[];
+  classLoaded: ClassReferenceLoaded;
+}

lib/parse/ParameterLoader.ts

@@ -12,6 +12,7 @@ import type { ClassReferenceLoaded, InterfaceLoaded, ClassReference,
   ClassReferenceLoadedClassOrInterface, ClassIndex } from './ClassIndex';
 import type { CommentData, ConstructorCommentData, CommentLoader } from './CommentLoader';
 import type { ConstructorData, ConstructorHolder } from './ConstructorLoader';
+import type { GenericsData } from './GenericsLoader';
 import type { TypeReferenceOverride } from './typereferenceoverride/TypeReferenceOverride';
 import { TypeReferenceOverrideAliasRecord } from './typereferenceoverride/TypeReferenceOverrideAliasRecord';
 
@@ -100,43 +101,50 @@ export class ParameterLoader {
     // Load the constructor comment
     const constructorCommentData = this.commentLoader.getCommentDataFromConstructor(constructorChain);
 
+    // Load all constructor parameters
+    const parameters: ParameterDataField<ParameterRangeUnresolved>[] = [];
+    for (const field of constructorChain[0].constructor.value.params) {
+      this.loadConstructorField(classLoaded, parameters, constructorCommentData, field);
+    }
+
+    return {
+      parameters,
+      classLoaded,
+    };
+  }
+
+  /**
+   * Load generics types from the given class.
+   * @param classLoaded A loaded class.
+   */
+  public loadClassGenerics(classLoaded: ClassReferenceLoadedClassOrInterface): GenericsData<ParameterRangeUnresolved> {
     // Load all generic type parameters
     const genericTypeParameters: GenericTypeParameterData<ParameterRangeUnresolved>[] = [];
     for (const [ genericName, genericType ] of Object.entries(classLoaded.generics)) {
-      this.loadConstructorGeneric(
+      this.loadClassGeneric(
         classLoaded,
         genericTypeParameters,
-        constructorCommentData,
         genericName,
         genericType.type,
       );
     }
 
-    // Load all constructor parameters
-    const parameters: ParameterDataField<ParameterRangeUnresolved>[] = [];
-    for (const field of constructorChain[0].constructor.value.params) {
-      this.loadConstructorField(classLoaded, parameters, constructorCommentData, field);
-    }
-
     return {
       genericTypeParameters,
-      parameters,
       classLoaded,
     };
   }
 
   /**
-   * Load the generic type parameter data from the given generic in a constructor.
+   * Load the generic type parameter data from the given generic in a class.
    * @param classLoaded The loaded class in which the field is defined.
    * @param genericTypeParameters The array of generic type parameters that will be appended to.
-   * @param constructorCommentData Comment data from the constructor.
    * @param genericName The generic type name.
    * @param genericType The optional generic type range.
    */
-  public loadConstructorGeneric(
+  public loadClassGeneric(
     classLoaded: ClassReferenceLoaded,
     genericTypeParameters: GenericTypeParameterData<ParameterRangeUnresolved>[],
-    constructorCommentData: ConstructorCommentData,
     genericName: string,
     genericType: TypeNode | undefined,
   ): void {

lib/parse/ParameterResolver.ts

@@ -5,6 +5,7 @@ import type { ClassIndex, ClassReference, ClassReferenceLoaded, InterfaceLoaded
 import type { ClassLoader } from './ClassLoader';
 import type { CommentLoader } from './CommentLoader';
 import type { ConstructorData } from './ConstructorLoader';
+import type { GenericsData } from './GenericsLoader';
 import type {
   ExtensionData,
   GenericTypeParameterData,
@@ -56,11 +57,6 @@ export class ParameterResolver {
     unresolvedConstructorData: ConstructorData<ParameterRangeUnresolved>,
   ): Promise<ConstructorData<ParameterRangeResolved>> {
     return {
-      genericTypeParameters: await this.resolveGenericTypeParameterData(
-        unresolvedConstructorData.genericTypeParameters,
-        unresolvedConstructorData.classLoaded,
-        {},
-      ),
       parameters: <ParameterDataField<ParameterRangeResolved>[]> (await this.resolveParameterData(
         unresolvedConstructorData.parameters,
         unresolvedConstructorData.classLoaded,
@@ -70,6 +66,31 @@ export class ParameterResolver {
     };
   }
 
+  /**
+   * Resolve all generic type parameters of a given constructor index.
+   * @param unresolvedParametersIndex An index of unresolved constructor data.
+   */
+  public async resolveAllGenericTypeParameterData(
+    unresolvedParametersIndex: ClassIndex<GenericsData<ParameterRangeUnresolved>>,
+  ): Promise<ClassIndex<GenericsData<ParameterRangeResolved>>> {
+    const resolvedGenericsIndex: ClassIndex<GenericsData<ParameterRangeResolved>> = {};
+
+    // Resolve parameters for the different constructors in parallel
+    await Promise.all(Object.entries(unresolvedParametersIndex)
+      .map(async([ className, unresolvedGenericsData ]) => {
+        resolvedGenericsIndex[className] = {
+          genericTypeParameters: await this.resolveGenericTypeParameterData(
+            unresolvedGenericsData.genericTypeParameters,
+            unresolvedGenericsData.classLoaded,
+            {},
+          ),
+          classLoaded: unresolvedGenericsData.classLoaded,
+        };
+      }));
+
+    return resolvedGenericsIndex;
+  }
+
   /**
    * Resolve the given array of generic type parameter data in parallel.
    * @param genericTypeParameters An array of unresolved generic type parameters.

lib/serialize/ComponentConstructor.ts

@@ -8,6 +8,7 @@ import type {
   ClassReferenceLoadedClassOrInterface,
 } from '../parse/ClassIndex';
 import type { ConstructorData } from '../parse/ConstructorLoader';
+import type { GenericsData } from '../parse/GenericsLoader';
 import type { PackageMetadata } from '../parse/PackageMetadataLoader';
 import type { DefaultNested,
   DefaultValue,
@@ -33,6 +34,7 @@ export class ComponentConstructor {
   private readonly pathDestination: PathDestinationDefinition;
   private readonly classAndInterfaceIndex: ClassIndex<ClassReferenceLoadedClassOrInterface>;
   private readonly classConstructors: ClassIndex<ConstructorData<ParameterRangeResolved>>;
+  private readonly classGenerics: ClassIndex<GenericsData<ParameterRangeResolved>>;
   private readonly classExtensions: ClassIndex<ExtensionData<ParameterRangeResolved>[]>;
   private readonly externalComponents: ExternalComponents;
   private readonly contextParser: ContextParser;
@@ -44,6 +46,7 @@ export class ComponentConstructor {
     this.pathDestination = args.pathDestination;
     this.classAndInterfaceIndex = args.classAndInterfaceIndex;
     this.classConstructors = args.classConstructors;
+    this.classGenerics = args.classGenerics;
     this.classExtensions = args.classExtensions;
     this.externalComponents = args.externalComponents;
     this.contextParser = args.contextParser;
@@ -84,6 +87,7 @@ export class ComponentConstructor {
         },
         classReference,
         this.classConstructors[className],
+        this.classGenerics[className],
         this.classExtensions[className],
       ));
     }
@@ -166,22 +170,24 @@ export class ComponentConstructor {
    * @param externalContextsCallback Callback for external contexts.
    * @param classReference Class reference of the class component.
    * @param constructorData Constructor data of the owning class.
+   * @param genericsData Generics data of the owning class.
    * @param classExtensions Class extensions of the owning class.
    */
   public async constructComponent(
     context: JsonLdContextNormalized,
     externalContextsCallback: ExternalContextCallback,
     classReference: ClassReferenceLoadedClassOrInterface,
     constructorData: ConstructorData<ParameterRangeResolved> | undefined,
+    genericsData: GenericsData<ParameterRangeResolved> | undefined,
     classExtensions: ExtensionData<ParameterRangeResolved>[] | undefined,
   ): Promise<ComponentDefinition> {
     // Determine generic type parameters
-    const genericTypeParameters = constructorData ?
+    const genericTypeParameters = genericsData ?
       await this.constructGenericTypeParameters(
         context,
         externalContextsCallback,
         classReference,
-        constructorData.genericTypeParameters,
+        genericsData.genericTypeParameters,
       ) :
       undefined;
 
@@ -799,6 +805,7 @@ export interface ComponentConstructorArgs {
   pathDestination: PathDestinationDefinition;
   classAndInterfaceIndex: ClassIndex<ClassReferenceLoadedClassOrInterface>;
   classConstructors: ClassIndex<ConstructorData<ParameterRangeResolved>>;
+  classGenerics: ClassIndex<GenericsData<ParameterRangeResolved>>;
   classExtensions: ClassIndex<ExtensionData<ParameterRangeResolved>[]>;
   externalComponents: ExternalComponents;
   contextParser: ContextParser;

test/parse/ConstructorLoader.test.ts

@@ -43,7 +43,6 @@ describe('ConstructorLoader', () => {
         A,
       })).toEqual({
         A: {
-          genericTypeParameters: [],
           parameters: [],
           classLoaded: A,
         },
@@ -64,7 +63,6 @@ describe('ConstructorLoader', () => {
         A,
       })).toEqual({
         A: {
-          genericTypeParameters: [],
           parameters: [],
           classLoaded: A,
         },
@@ -109,7 +107,6 @@ export class B{
         B,
       })).toEqual({
         A: {
-          genericTypeParameters: [],
           parameters: [
             {
               type: 'field',
@@ -144,7 +141,6 @@ export class B{
           classLoaded: A,
         },
         B: {
-          genericTypeParameters: [],
           parameters: [
             {
               type: 'field',
@@ -191,7 +187,6 @@ export class B{
         A,
       })).toEqual({
         A: {
-          genericTypeParameters: [],
           parameters: [
             {
               type: 'field',
@@ -226,58 +221,6 @@ export class B{
         },
       });
     });
-
-    it('should return for a single class with generic types', async() => {
-      resolutionContext.contentsOverrides = {
-        'file.d.ts': `export class A<A, B extends number, C extends Class<B, string>>{
-  constructor(){}
-}`,
-      };
-      const A = await classIndexer.loadClassChain({
-        packageName: 'p',
-        localName: 'A',
-        fileName: 'file',
-        fileNameReferenced: 'fileReferenced',
-      });
-      expect(parser.getConstructors({
-        A,
-      })).toEqual({
-        A: {
-          genericTypeParameters: [
-            {
-              name: 'A',
-            },
-            {
-              name: 'B',
-              range: {
-                type: 'raw',
-                value: 'number',
-              },
-            },
-            {
-              name: 'C',
-              range: {
-                type: 'interface',
-                value: 'Class',
-                genericTypeParameterInstantiations: [
-                  {
-                    type: 'genericTypeReference',
-                    value: 'B',
-                  },
-                  {
-                    type: 'raw',
-                    value: 'string',
-                  },
-                ],
-                origin: expect.anything(),
-              },
-            },
-          ],
-          parameters: [],
-          classLoaded: A,
-        },
-      });
-    });
   });
 
   describe('getConstructor', () => {