feat(type-compiler): support trivially inferred types

marcj · marcj · commit 087b60ae8f96 · 2025-01-31T22:50:17.000+01:00
This makes types of all properties of code like this

```
    class A {
        a = 1;
        b = '2';
        c = true;
        d = 2n;
        e = Symbol('e');
        f = new Date();
        g = new Uint8Array();
    }
```

available in runtime.
diff --git a/packages/type-compiler/install-transformer.ts b/packages/type-compiler/install-transformer.ts
@@ -28,13 +28,22 @@ function getCode(deepkitDistPath: string, varName: string, id: string): string {
             if (typeTransformer) {
                 if (!customTransformers) ${varName} = {};
                 if (!${varName}.before) ${varName}.before = [];
-                if (!${varName}.before.includes(typeTransformer.transformer)) ${varName}.before.push(typeTransformer.transformer);
-
-                if (!${varName}.afterDeclarations) ${varName}.afterDeclarations = [];
-                if (!${varName}.afterDeclarations.includes(typeTransformer.declarationTransformer)) ${varName}.afterDeclarations.push(typeTransformer.declarationTransformer);
+                let alreadyPatched = false;
+                for (let fn of ${varName}.before) {
+                    if (fn && fn.name === 'deepkitTransformer') alreadyPatched = true;
+                }
+                if (!alreadyPatched) {
+                    if (!${varName}.before.includes(typeTransformer.transformer)) ${varName}.before.push(typeTransformer.transformer);
+
+                    if (!${varName}.afterDeclarations) ${varName}.afterDeclarations = [];
+                    if (!${varName}.afterDeclarations.includes(typeTransformer.declarationTransformer)) {
+                        ${varName}.afterDeclarations.push(typeTransformer.declarationTransformer);
+                    }
+                }
             }
         } catch (e) {
         }
+        //${getPatchId(id)}-end
     `;
 }
 
diff --git a/packages/type-compiler/src/compiler.ts b/packages/type-compiler/src/compiler.ts
@@ -14,6 +14,7 @@ import type {
     ArrowFunction,
     Block,
     Bundle,
+    CallExpression,
     CallSignatureDeclaration,
     ClassDeclaration,
     ClassElement,
@@ -49,6 +50,7 @@ import type {
     MethodSignature,
     Modifier,
     ModuleDeclaration,
+    NewExpression,
     Node,
     NodeFactory,
     ParseConfigHost,
@@ -1183,6 +1185,65 @@ export class ReflectionTransformer implements CustomTransformer {
         return [variable];
     }
 
+    protected extractPackStructOfExpression(node: Expression, program: CompilerProgram): void {
+        switch (node.kind) {
+            case SyntaxKind.StringLiteral: {
+                program.pushOp(ReflectionOp.string);
+                return;
+            }
+            case SyntaxKind.NumericLiteral: {
+                program.pushOp(ReflectionOp.number);
+                return;
+            }
+            case SyntaxKind.FalseKeyword:
+            case SyntaxKind.TrueKeyword: {
+                program.pushOp(ReflectionOp.boolean);
+                return;
+            }
+            case SyntaxKind.BigIntLiteral: {
+                program.pushOp(ReflectionOp.bigint);
+                return;
+            }
+            //Symbol() is a function call, so we need to check for that
+            case SyntaxKind.CallExpression: {
+                const call = node as CallExpression;
+                if (isIdentifier(call.expression) && getIdentifierName(call.expression) === 'Symbol') {
+                    program.pushOp(ReflectionOp.symbol);
+                    return;
+                }
+                break;
+            }
+            //new Date()
+            case SyntaxKind.NewExpression: {
+                const call = node as NewExpression;
+                if (isIdentifier(call.expression)) {
+                    const map: {[name: string]: ReflectionOp} = {
+                        'Date': ReflectionOp.date,
+                        'RegExp': ReflectionOp.regexp,
+                        'Uint8Array': ReflectionOp.uint8Array,
+                        'Uint8ClampedArray': ReflectionOp.uint8ClampedArray,
+                        'Uint16Array': ReflectionOp.uint16Array,
+                        'Uint32Array': ReflectionOp.uint32Array,
+                        'Int8Array': ReflectionOp.int8Array,
+                        'Int16Array': ReflectionOp.int16Array,
+                        'Int32Array': ReflectionOp.int32Array,
+                        'Float32Array': ReflectionOp.float32Array,
+                        'Float64Array': ReflectionOp.float64Array,
+                        'ArrayBuffer': ReflectionOp.arrayBuffer,
+                    };
+                    const op = map[getIdentifierName(call.expression)];
+                    if (op) {
+                        program.pushOp(op);
+                        return;
+                    }
+                }
+                break;
+            }
+        }
+
+        program.pushOp(ReflectionOp.never);
+    }
+
     protected extractPackStructOfType(node: Node | Declaration | ClassDeclaration | ClassExpression, program: CompilerProgram): void {
         if (isParenthesizedTypeNode(node)) return this.extractPackStructOfType(node.type, program);
 
@@ -1500,32 +1561,36 @@ export class ReflectionTransformer implements CustomTransformer {
                 //TypeScript does not narrow types down
                 const narrowed = node as PropertyDeclaration;
 
-                if (narrowed.type) {
-                    // if the property was explicitly marked as `@reflection no`, we ignore it
-                    if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) return;
+                // if the property was explicitly marked as `@reflection no`, we ignore it
+                if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) return;
 
+                if (narrowed.type) {
                     this.extractPackStructOfType(narrowed.type, program);
-                    const name = getPropertyName(this.f, narrowed.name);
-                    program.pushOp(ReflectionOp.property, program.findOrAddStackEntry(name));
+                } else if (narrowed.initializer) {
+                    this.extractPackStructOfExpression(narrowed.initializer, program);
+                }
 
-                    if (narrowed.questionToken) program.pushOp(ReflectionOp.optional);
-                    if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
-                    if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(ReflectionOp.private);
-                    if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
-                    if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(ReflectionOp.abstract);
-                    if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(ReflectionOp.static);
+                const name = getPropertyName(this.f, narrowed.name);
+                program.pushOp(ReflectionOp.property, program.findOrAddStackEntry(name));
 
-                    if (narrowed.initializer) {
-                        //important to use Function, since it will be called using a different `this`
-                        program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(
-                            this.f.createFunctionExpression(undefined, undefined, undefined, undefined, undefined, undefined,
-                                this.f.createBlock([this.f.createReturnStatement(narrowed.initializer)])),
-                        ));
-                    }
+                if (narrowed.questionToken) program.pushOp(ReflectionOp.optional);
+                if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
+                if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(ReflectionOp.private);
+                if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
+                if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(ReflectionOp.abstract);
+                if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(ReflectionOp.static);
 
-                    const description = extractJSDocAttribute(this.sourceFile, narrowed, 'description');
-                    if (description) program.pushOp(ReflectionOp.description, program.findOrAddStackEntry(description));
+                if (narrowed.initializer) {
+                    //important to use Function, since it will be called using a different `this`
+                    program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(
+                        this.f.createFunctionExpression(undefined, undefined, undefined, undefined, undefined, undefined,
+                            this.f.createBlock([this.f.createReturnStatement(narrowed.initializer)])),
+                    ));
                 }
+
+                const description = extractJSDocAttribute(this.sourceFile, narrowed, 'description');
+                if (description) program.pushOp(ReflectionOp.description, program.findOrAddStackEntry(description));
+
                 break;
             }
             case SyntaxKind.ConditionalType: {
diff --git a/packages/type-compiler/tests/transpile.spec.ts b/packages/type-compiler/tests/transpile.spec.ts
@@ -580,3 +580,15 @@ test('symbol function name', () => {
     console.log(res.app);
     expect(res.app).toContain(`() => Symbol.iterator`);
 });
+
+test('infer type', () => {
+    const res = transpile({
+        'app': `
+        class A {
+            a = 1;
+        }
+        `
+    });
+    console.log(res.app);
+    expect(res.app).toContain(`'a'`);
+});
diff --git a/packages/type/tests/issues/infer-types.spec.ts b/packages/type/tests/issues/infer-types.spec.ts
@@ -0,0 +1,49 @@
+import { expect, test } from '@jest/globals';
+import { typeOf } from '../../src/reflection/reflection';
+import { assertType, findMember, ReflectionKind, stringifyResolvedType } from '../../src/reflection/type';
+
+test('basics', () => {
+    class A {
+        a = 1;
+        b = '2';
+        c = true;
+        d = 2n;
+        e = Symbol('e');
+        f = new Date();
+        g = new Uint8Array();
+    }
+
+    const type = typeOf<A>();
+    console.log(stringifyResolvedType(type));
+
+    assertType(type, ReflectionKind.class);
+    const a = findMember('a', type.types);
+    assertType(a, ReflectionKind.property);
+    assertType(a.type, ReflectionKind.number);
+
+    const b = findMember('b', type.types);
+    assertType(b, ReflectionKind.property);
+    assertType(b.type, ReflectionKind.string);
+
+    const c = findMember('c', type.types);
+    assertType(c, ReflectionKind.property);
+    assertType(c.type, ReflectionKind.boolean);
+
+    const d = findMember('d', type.types);
+    assertType(d, ReflectionKind.property);
+    assertType(d.type, ReflectionKind.bigint);
+
+    const e = findMember('e', type.types);
+    assertType(e, ReflectionKind.property);
+    assertType(e.type, ReflectionKind.symbol);
+
+    const f = findMember('f', type.types);
+    assertType(f, ReflectionKind.property);
+    assertType(f.type, ReflectionKind.class);
+    expect(f.type.classType).toBe(Date);
+
+    const g = findMember('g', type.types);
+    assertType(g, ReflectionKind.property);
+    assertType(g.type, ReflectionKind.class);
+    expect(g.type.classType).toBe(Uint8Array);
+});
