feat(type-compiler): emit typeName for type only imports

Author: marcus-sa

packages/type-compiler/src/compiler.ts

@@ -1314,7 +1314,7 @@ export class ReflectionTransformer implements CustomTransformer {
                         }
                     }
 
-                    if (narrowed.name) program.pushOp(ReflectionOp.typeName, program.findOrAddStackEntry(getIdentifierName(narrowed.name)));
+                    if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
 
                     const description = extractJSDocAttribute(narrowed, 'description');
                     if (description) program.pushOp(ReflectionOp.description, program.findOrAddStackEntry(description));
@@ -2125,7 +2125,7 @@ export class ReflectionTransformer implements CustomTransformer {
                         if (resolved.importDeclaration) {
                             //if explicit `import {type T}`, we do not emit an import and instead push any
                             if (resolved.typeOnly) {
-                                program.pushOp(ReflectionOp.any);
+                                this.resolveTypeOnlyImport(typeName, program);
                                 return;
                             }
 
@@ -2206,7 +2206,7 @@ export class ReflectionTransformer implements CustomTransformer {
             } else if (isClassDeclaration(declaration) || isFunctionDeclaration(declaration) || isFunctionExpression(declaration) || isArrowFunction(declaration)) {
                 //if explicit `import {type T}`, we do not emit an import and instead push any
                 if (resolved.typeOnly) {
-                    program.pushOp(ReflectionOp.any);
+                    this.resolveTypeOnlyImport(typeName, program);
                     return;
                 }
 
@@ -2308,6 +2308,18 @@ export class ReflectionTransformer implements CustomTransformer {
         return declarationUser !== typeUser;
     }
 
+    protected resolveTypeOnlyImport(entityName: EntityName, program: CompilerProgram) {
+        program.pushOp(ReflectionOp.any);
+        const typeName = ts.isIdentifier(entityName)
+            ? getIdentifierName(entityName)
+            : getIdentifierName(entityName.right);
+        this.resolveTypeName(typeName, program);
+    }
+
+    protected resolveTypeName(typeName: string, program: CompilerProgram) {
+        program.pushOp(ReflectionOp.typeName, program.findOrAddStackEntry(typeName));
+    }
+
     protected resolveTypeParameter(declaration: TypeParameterDeclaration, type: TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram) {
         //check if `type` was used in an expression. if so, we need to resolve it from runtime, otherwise we mark it as T
         const isUsedInFunction = isFunctionLike(declaration.parent);

packages/type/tests/compiler.spec.ts

@@ -1747,6 +1747,25 @@ test('import types named import cjs', () => {
     expect(js['user.d.ts']).toContain(`export declare type __ΩUser = any[]`);
 });
 
+test('emit typeName for type only imports', () => {
+    const js = transpile({
+        'app': `
+            import {type User} from './user.js';
+            typeOf<User>();
+        `,
+        'user': `export interface User {id: number}`
+    }, {
+        module: ModuleKind.CommonJS
+    });
+    const typeOf = typeOf2;
+    expect(eval(js['app.js'])).toMatchInlineSnapshot(`
+        {
+          "kind": 1,
+          "typeName": "User",
+        }
+    `);
+});
+
 test('import types named import typeOnly', () => {
     const js = transpile({
         'app': `