Handle generically typed parameters

Author: rubensworks

lib/parse/ClassIndex.ts

@@ -1,4 +1,4 @@
-import { ClassDeclaration, TSInterfaceDeclaration } from '@typescript-eslint/types/dist/ts-estree';
+import { ClassDeclaration, TSInterfaceDeclaration, TypeNode } from '@typescript-eslint/types/dist/ts-estree';
 import { AST, TSESTreeOptions } from '@typescript-eslint/typescript-estree';
 
 /**
@@ -43,6 +43,15 @@ export interface ClassLoaded extends ClassReference {
   abstract?: boolean;
   // The tsdoc comment of this class
   comment?: string;
+  // The generic types of this class
+  generics: GenericTypes;
+}
+
+/**
+ * A hash of generic type name to its properties.
+ */
+export interface GenericTypes {
+  [name: string]: { type?: TypeNode };
 }
 
 /**
@@ -62,4 +71,6 @@ export interface InterfaceLoaded extends ClassReference {
   superInterfaces?: InterfaceLoaded[];
   // The tsdoc comment of this class
   comment?: string;
+  // The generic types of this class
+  generics: GenericTypes;
 }

lib/parse/ClassLoader.ts

@@ -1,8 +1,8 @@
 import * as Path from 'path';
 import { ClassDeclaration, TSInterfaceDeclaration } from '@typescript-eslint/types/dist/ts-estree';
-import { AST, TSESTreeOptions, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import { AST, AST_NODE_TYPES, TSESTreeOptions } from '@typescript-eslint/typescript-estree';
 import { ResolutionContext } from '../resolution/ResolutionContext';
-import { ClassLoaded, ClassReference, ClassReferenceLoaded, InterfaceLoaded } from './ClassIndex';
+import { ClassLoaded, ClassReference, ClassReferenceLoaded, GenericTypes, InterfaceLoaded } from './ClassIndex';
 import { CommentLoader } from './CommentLoader';
 
 /**
@@ -77,45 +77,53 @@ export class ClassLoader {
 
     // If the class has been exported in this file, return directly
     if (classReference.localName in exportedClasses) {
+      const declaration = exportedClasses[classReference.localName];
       return <any> this.enhanceLoadedWithComment(<ClassLoaded> {
         type: 'class',
         ...classReference,
-        declaration: exportedClasses[classReference.localName],
+        declaration,
         ast,
-        abstract: exportedClasses[classReference.localName].abstract,
+        abstract: declaration.abstract,
+        generics: this.collectGenericTypes(declaration),
       });
     }
 
     // If the class has been declared in this file, return directly
     if (classReference.localName in declaredClasses) {
+      const declaration = declaredClasses[classReference.localName];
       return <any> this.enhanceLoadedWithComment(<ClassLoaded> {
         type: 'class',
         ...classReference,
-        declaration: declaredClasses[classReference.localName],
+        declaration,
         ast,
-        abstract: declaredClasses[classReference.localName].abstract,
+        abstract: declaration.abstract,
+        generics: this.collectGenericTypes(declaration),
       });
     }
 
     // Only consider interfaces if explicitly enabled
     if (considerInterfaces) {
       // If the interface has been exported in this file, return directly
       if (classReference.localName in exportedInterfaces) {
+        const declaration = exportedInterfaces[classReference.localName];
         return <any> this.enhanceLoadedWithComment(<InterfaceLoaded> {
           type: 'interface',
           ...classReference,
-          declaration: exportedInterfaces[classReference.localName],
+          declaration,
           ast,
+          generics: this.collectGenericTypes(declaration),
         });
       }
 
       // If the interface has been declared in this file, return directly
       if (classReference.localName in declaredInterfaces) {
+        const declaration = declaredInterfaces[classReference.localName];
         return <any> this.enhanceLoadedWithComment(<InterfaceLoaded> {
           type: 'interface',
           ...classReference,
-          declaration: declaredInterfaces[classReference.localName],
+          declaration,
           ast,
+          generics: this.collectGenericTypes(declaration),
         });
       }
     }
@@ -143,6 +151,20 @@ export class ClassLoader {
     throw new Error(`Could not load ${considerInterfaces ? 'class or interface' : 'class'} ${classReference.localName} from ${classReference.fileName}`);
   }
 
+  /**
+   * Create a hash of generic types in the given class declaration.
+   * @param classDeclaration A class or interface declaration.
+   */
+  public collectGenericTypes(classDeclaration: ClassDeclaration | TSInterfaceDeclaration): GenericTypes {
+    const genericTypes: GenericTypes = {};
+    if (classDeclaration.typeParameters) {
+      for (const param of classDeclaration.typeParameters.params) {
+        genericTypes[param.name.name] = { type: param.constraint };
+      }
+    }
+    return genericTypes;
+  }
+
   /**
    * Annotate the given loaded class or interface with a comment if it is present on the declaration.
    * @param classLoaded A loaded class or interface.

lib/parse/ParameterLoader.ts

@@ -155,6 +155,17 @@ export class ParameterLoader {
               throw new Error(`Found invalid Array field type at ${this.getFieldName(field)
               } in ${this.classLoaded.localName} at ${this.classLoaded.fileName}`);
             default:
+              // First check if the type is be a generic type
+              if (typeNode.typeName.name in this.classLoaded.generics) {
+                const genericProperties = this.classLoaded.generics[typeNode.typeName.name];
+                if (!genericProperties.type) {
+                  throw new Error(`Found untyped generic field type at ${this.getFieldName(field)
+                  } in ${this.classLoaded.localName} at ${this.classLoaded.fileName}`);
+                }
+                return this.getRangeFromTypeNode(genericProperties.type, field);
+              }
+
+              // Otherwise, assume we have an interface/class parameter
               return { type: 'interface', value: typeNode.typeName.name };
           }
         }