Reflect template parameter default values and use them as type arguments

src/lib/converter/context.ts

@@ -296,7 +296,7 @@ export class Context {
      * @param typeArguments  The type arguments that apply while inheriting the given node.
      * @return The resulting reflection / the current scope.
      */
-    inherit(baseNode: ts.Node, typeArguments?: ts.NodeArray<ts.TypeNode>): Reflection {
+    inherit(baseNode: ts.Node, typeArguments?: ReadonlyArray<ts.TypeNode>): Reflection {
         const wasInherit = this.isInherit;
         const oldInherited = this.inherited;
         const oldInheritParent = this.inheritParent;

src/lib/converter/factories/type-parameter.ts

@@ -20,6 +20,9 @@ export function createTypeParameter(context: Context, node: ts.TypeParameterDecl
     if (node.constraint) {
         typeParameter.constraint = context.converter.convertType(context, node.constraint);
     }
+    if (node.default) {
+        typeParameter.default = context.converter.convertType(context, node.default);
+    }
 
     const reflection = <TypeParameterContainer> context.scope;
     const typeParameterReflection = new TypeParameterReflection(typeParameter, reflection);

src/lib/converter/nodes/class.ts

@@ -6,6 +6,7 @@ import { createDeclaration } from '../factories/index';
 import { Context } from '../context';
 import { Component, ConverterNodeComponent } from '../components';
 import { toArray } from 'lodash';
+import { getTypeArgumentsWithDefaults, getTypeParametersOfType } from '../utils/types';
 
 @Component({name: 'node:class'})
 export class ClassConverter extends ConverterNodeComponent<ts.ClassDeclaration> {
@@ -64,14 +65,24 @@ export class ClassConverter extends ConverterNodeComponent<ts.ClassDeclaration>
                 if (type) {
                     const typesToInheritFrom: ts.Type[] = type.isIntersection() ? type.types : [ type ];
 
+                    // Get type parameters of all types
+                    let typeParams: ts.TypeParameterDeclaration[] = [];
+                    for (const typeToInheritFrom of typesToInheritFrom) {
+                        typeParams = typeParams.concat(getTypeParametersOfType(typeToInheritFrom));
+                    }
+
+                    const typeArguments = typeParams.length > 0
+                        ? getTypeArgumentsWithDefaults(typeParams, baseType.typeArguments)
+                        : undefined;
+
                     typesToInheritFrom.forEach((typeToInheritFrom: ts.Type) => {
                         // TODO: The TS declaration file claims that:
                         // 1. type.symbol is non-nullable
                         // 2. symbol.declarations is non-nullable
                         // These are both incorrect, GH#1207 for #2 and existing tests for #1.
                         // Figure out why this is the case and document.
                         typeToInheritFrom.symbol?.declarations?.forEach((declaration) => {
-                            context.inherit(declaration, baseType.typeArguments);
+                            context.inherit(declaration, typeArguments);
                         });
                     });
                 }

src/lib/converter/utils/types.ts

@@ -0,0 +1,51 @@
+import * as ts from 'typescript';
+
+/**
+ * Returns the type parameters of a given type.
+ * @param type The type whos type parameters are wanted.
+ * @returns The type parameters of the type. An empty array if the type has no type parameters.
+ */
+export function getTypeParametersOfType(type: ts.Type): ReadonlyArray<ts.TypeParameterDeclaration> {
+    const declarations = type.getSymbol()?.getDeclarations() ?? [];
+
+    for (const declaration of declarations) {
+        if ((ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) &&
+             declaration.typeParameters) {
+            return declaration.typeParameters;
+        }
+    }
+
+    return [];
+}
+
+/**
+ * Returns a list of type arguments. If a type parameter has no corresponding type argument, the default type
+ * for that type parameter is used as the type argument.
+ * @param typeParams The type parameters for which the type arguments are wanted.
+ * @param typeArguments The type arguments as provided in the declaration.
+ * @returns The complete list of type arguments with possible default values if type arguments are missing.
+ */
+export function getTypeArgumentsWithDefaults(
+    typeParams: ts.TypeParameterDeclaration[],
+    typeArguments?: ReadonlyArray<ts.TypeNode>
+): ReadonlyArray<ts.TypeNode> {
+    if (!typeArguments || typeParams.length > typeArguments.length) {
+        const typeArgumentsWithDefaults = new Array<ts.TypeNode>();
+
+        for (let i = 0; i < typeParams.length; ++i) {
+            if (typeArguments && typeArguments[i]) {
+                typeArgumentsWithDefaults.push(typeArguments[i]);
+            } else {
+                const defaultType = typeParams[i].default;
+
+                if (defaultType) {
+                    typeArgumentsWithDefaults.push(defaultType);
+                }
+            }
+        }
+
+        return typeArgumentsWithDefaults;
+    }
+
+    return typeArguments;
+}

src/lib/models/reflections/type-parameter.ts

@@ -7,11 +7,14 @@ export class TypeParameterReflection extends Reflection implements TypeContainer
 
     type?: Type;
 
+    default?: Type;
+
     /**
      * Create a new TypeParameterReflection instance.
      */
     constructor(type: TypeParameterType, parent?: Reflection) {
         super(type.name, ReflectionKind.TypeParameter, parent);
         this.type = type.constraint;
+        this.default = type.default;
     }
 }

src/lib/models/types/type-parameter.ts

@@ -15,6 +15,15 @@ export class TypeParameterType extends Type {
 
     constraint?: Type;
 
+    /**
+     * Default type for the type parameter.
+     *
+     * ```
+     * class SomeClass<T = {}>
+     * ```
+     */
+    default?: Type;
+
     /**
      * The type name identifier.
      */
@@ -33,6 +42,7 @@ export class TypeParameterType extends Type {
     clone(): Type {
         const clone = new TypeParameterType(this.name);
         clone.constraint = this.constraint;
+        clone.default = this.default;
         return clone;
     }
 
@@ -47,19 +57,29 @@ export class TypeParameterType extends Type {
             return false;
         }
 
+        let constraintEquals = false;
+
         if (this.constraint && type.constraint) {
-            return type.constraint.equals(this.constraint);
+            constraintEquals = type.constraint.equals(this.constraint);
         } else if (!this.constraint && !type.constraint) {
-            return true;
-        } else {
-            return false;
+            constraintEquals = true;
         }
+
+        let defaultEquals = false;
+
+        if (this.default && type.default) {
+            defaultEquals = type.default.equals(this.default);
+        } else if (!this.default && !type.default) {
+            defaultEquals = true;
+        }
+
+        return constraintEquals && defaultEquals;
     }
 
     /**
      * Return a string representation of this type.
      */
-    toString() {
+    toString(): string {
         return this.name;
     }
 }

src/lib/serialization/schema.ts

@@ -222,7 +222,7 @@ export interface TupleType extends Type, S<M.TupleType, 'type'> {
 export interface TypeOperatorType extends Type, S<M.TypeOperatorType, 'type' | 'operator' | 'target'> {
 }
 
-export interface TypeParameterType extends Type, S<M.TypeParameterType, 'type' | 'name' | 'constraint'> {
+export interface TypeParameterType extends Type, S<M.TypeParameterType, 'type' | 'name' | 'constraint' | 'default'> {
 }
 
 export interface UnionType extends Type, S<M.UnionType, 'type' | 'types'> {

src/lib/serialization/serializers/types/type-parameter.ts

@@ -17,6 +17,9 @@ export class TypeParameterTypeSerializer extends TypeSerializerComponent<TypePar
         if (type.constraint) {
             result.constraint = this.owner.toObject(type.constraint);
         }
+        if (type.default) {
+            result.default = this.owner.toObject(type.default);
+        }
 
         return result;
     }