feat(type-compiler): resolve type name for classes

Author: marcus-sa

packages/type-compiler/src/compiler.ts

@@ -1301,7 +1301,8 @@ export class ReflectionTransformer implements CustomTransformer {
                         this.extractPackStructOfType(member, program);
                     }
 
-                    program.pushOp(ReflectionOp.class);
+                    this.resolveClass(narrowed, program);
+
                     if (description) program.pushOp(ReflectionOp.description, program.findOrAddStackEntry(description));
 
                     if (narrowed.heritageClauses && narrowed.heritageClauses[0] && narrowed.heritageClauses[0].types[0]) {
@@ -2315,6 +2316,11 @@ export class ReflectionTransformer implements CustomTransformer {
         program.pushOp(ReflectionOp.typeName, program.findOrAddStackEntry(typeName));
     }
 
+    protected resolveClass(node: ClassDeclaration | ClassExpression, program: CompilerProgram) {
+        program.pushOp(ReflectionOp.class);
+        this.resolveTypeName(getIdentifierName(node.name!), program);
+    }
+
     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

@@ -1787,6 +1787,22 @@ test('import types named import typeOnly has typeName', () => {
     `);
 });
 
+test('class has typeName', () => {
+    const js = transpile(`
+        class Test {}
+        typeOf<Test>();
+    `);
+    const typeOf = typeOf2;
+    expect(eval(js)).toMatchInlineSnapshot(`
+        {
+          "classType": [Function],
+          "kind": 20,
+          "typeName": "Test",
+          "types": [],
+        }
+    `);
+});
+
 test('import types named import with disabled reflection', () => {
     const js = transpile({
         'app': `