Add functionality to capture type aliases with type parameters

Author: woutervh-

debug/debug.ts

@@ -8,7 +8,7 @@ import { transformNode } from '../src/transform-inline/transform-node';
 import { PartialVisitorContext } from '../src/transform-inline/visitor-context';
 
 const configFilename = path.resolve('tsconfig.json');
-const inFile = path.resolve('test-fixtures', 'issue-52.ts');
+const inFile = path.resolve('test', 'issue-59.ts');
 const content = ts.sys.readFile(configFilename);
 if (content === undefined) {
     throw new Error('Could not read config file.');

src/transform-inline/visitor-type-check.ts

@@ -428,6 +428,17 @@ function visitRegularObjectType(type: ts.ObjectType, visitorContext: VisitorCont
     });
 }
 
+function visitTypeAliasReference(type: ts.TypeReference, visitorContext: VisitorContext) {
+    const mapping: Map<ts.Type, ts.Type> = VisitorUtils.getTypeAliasMapping(type);
+    const previousTypeReference = visitorContext.previousTypeReference;
+    visitorContext.typeMapperStack.push(mapping);
+    visitorContext.previousTypeReference = type;
+    const result = visitType(type, visitorContext);
+    visitorContext.previousTypeReference = previousTypeReference;
+    visitorContext.typeMapperStack.pop();
+    return result;
+}
+
 function visitTypeReference(type: ts.TypeReference, visitorContext: VisitorContext) {
     const mapping: Map<ts.Type, ts.Type> = VisitorUtils.getTypeReferenceMapping(type, visitorContext);
     const previousTypeReference = visitorContext.previousTypeReference;
@@ -683,7 +694,9 @@ function visitIndexedAccessType(type: ts.IndexedAccessType, visitorContext: Visi
 }
 
 export function visitType(type: ts.Type, visitorContext: VisitorContext): string {
-    if ((ts.TypeFlags.Any & type.flags) !== 0) {
+    if (type.aliasTypeArguments && visitorContext.previousTypeReference !== type && (type as ts.TypeReference).target) {
+        return visitTypeAliasReference(type as ts.TypeReference, visitorContext);
+    } else if ((ts.TypeFlags.Any & type.flags) !== 0) {
         // Any
         return visitAny(visitorContext);
     } else if ((ts.TypeFlags.Unknown & type.flags) !== 0) {

src/transform-inline/visitor-utils.ts

@@ -118,6 +118,20 @@ export function getPropertyInfo(parentType: ts.Type, symbol: ts.Symbol, visitorC
     throw new Error('Expected a valueDeclaration or a property type.');
 }
 
+export function getTypeAliasMapping(type: ts.TypeReference) {
+    const mapping: Map<ts.Type, ts.Type> = new Map();
+    if (type.aliasTypeArguments !== undefined && type.target.aliasTypeArguments !== undefined) {
+        const typeParameters = type.target.aliasTypeArguments;
+        const typeArguments = type.aliasTypeArguments;
+        for (let i = 0; i < typeParameters.length; i++) {
+            if (typeParameters[i] !== typeArguments[i]) {
+                mapping.set(typeParameters[i], typeArguments[i]);
+            }
+        }
+    }
+    return mapping;
+}
+
 export function getTypeReferenceMapping(type: ts.TypeReference, visitorContext: VisitorContext) {
     const mapping: Map<ts.Type, ts.Type> = new Map();
     (function checkBaseTypes(type: ts.TypeReference) {

test/issue-59.ts

@@ -0,0 +1,29 @@
+import * as assert from 'assert';
+import { is } from '../index';
+
+/* https://github.com/woutervh-/typescript-is/issues/59 */
+
+describe('is', () => {
+    type Row<T> = {
+        value: T;
+    };
+
+    describe('is<Row<number>>', () => {
+        it('should return true for Row objects with value a number', () => {
+            assert.deepStrictEqual(is<Row<number>>({ value: 0 }), true);
+            assert.deepStrictEqual(is<Row<number>>({ value: 1 }), true);
+            assert.deepStrictEqual(is<Row<number>>({ value: Number.NaN }), true);
+        });
+
+        it('should return false for Row objects with value not a number', () => {
+            assert.deepStrictEqual(is<Row<number>>({ value: '0' }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: '1' }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: true }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: false }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: {} }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: [] }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: null }), false);
+            assert.deepStrictEqual(is<Row<number>>({ value: undefined }), false);
+        });
+    });
+});