fix(type-compiler): don't emit 'any' for untyped functions, preserve fallback behavior

The #352 fix changed packOpsAndStack to return 'any' for empty ops, which
was correct for type aliases but broke arrow functions without explicit
type annotations. Functions like `() => this.value` were being wrapped
with `__assignType(fn, ['"'])` which caused ReflectionFunction.from() to
fail because it expects a function type, not 'any'.

The fix adds a getTypeOfFunction method that returns undefined for empty
ops (like the pre-#352 behavior), allowing ReflectionFunction.from() to
use its fallback path which creates a function type with 'any' return.

This preserves the #352 fix for type aliases while fixing the regression
for functions.

Adds tests for:
- Untyped arrow functions in type-compiler
- ReflectionFunction.from() with untyped arrow functions in type package

Author: marcj

packages/type-compiler/src/compiler.ts

@@ -2967,11 +2967,31 @@ export class ReflectionTransformer implements CustomTransformer {
         return this.packOpsAndStack(program);
     }
 
-    protected packOpsAndStack(program: CompilerProgram) {
+    /**
+     * Like getTypeOfType but returns undefined for empty ops instead of 'any'.
+     * Used for functions where empty ops means "can't determine type, don't decorate"
+     * rather than "external type, use any".
+     */
+    protected getTypeOfFunction(fn: Node | Declaration): Expression | undefined {
+        const reflection = this.isWithReflection(this.sourceFile, fn);
+        if (!reflection) return;
+
+        const program = new CompilerProgram(fn, this.sourceFile);
+        this.extractPackStructOfType(fn, program);
+        return this.packOpsAndStack(program, { emitAnyForEmptyOps: false });
+    }
+
+    protected packOpsAndStack(program: CompilerProgram, options?: { emitAnyForEmptyOps?: boolean }) {
         const packStruct = program.buildPackStruct();
         if (packStruct.ops.length === 0) {
             // External/excluded types produce empty ops - emit 'any' instead of
             // returning undefined which would create invalid JS: `const __ΩType;` (#352)
+            // However, for functions, empty ops means "can't determine type" and we should
+            // return undefined so the function isn't decorated (this preserves the fallback
+            // behavior in ReflectionFunction.from).
+            if (options?.emitAnyForEmptyOps === false) {
+                return undefined;
+            }
             return this.valueToExpression([encodeOps([ReflectionOp.any])]);
         }
         // debugPackStruct(this.sourceFile, program.forNode, packStruct);
@@ -3018,7 +3038,7 @@ export class ReflectionTransformer implements CustomTransformer {
      * => const fn = __assignType(function() {}, [34])
      */
     protected decorateFunctionExpression(expression: FunctionExpression) {
-        const encodedType = this.getTypeOfType(expression);
+        const encodedType = this.getTypeOfFunction(expression);
         if (!encodedType) return expression;
 
         return this.wrapWithAssignType(expression, encodedType);
@@ -3030,7 +3050,7 @@ export class ReflectionTransformer implements CustomTransformer {
      * => function name() {}; name.__type = 34;
      */
     protected decorateFunctionDeclaration(declaration: FunctionDeclaration, originalParent?: Node) {
-        const encodedType = this.getTypeOfType(declaration);
+        const encodedType = this.getTypeOfFunction(declaration);
         if (!encodedType) return declaration;
 
         if (!declaration.name) {
@@ -3067,7 +3087,7 @@ export class ReflectionTransformer implements CustomTransformer {
      * => const fn = __assignType(() => {}, [34])
      */
     protected decorateArrowFunction(expression: ArrowFunction) {
-        const encodedType = this.getTypeOfType(expression);
+        const encodedType = this.getTypeOfFunction(expression);
         if (!encodedType) return expression;
 
         return this.wrapWithAssignType(expression, encodedType);

packages/type-compiler/tests/function-type-hoisting.spec.ts

@@ -818,3 +818,104 @@ test('transpile: multiple functions all have hoisted __type', () => {
     const firstTypeIndex = res.app.indexOf('first.__type');
     expect(firstTypeIndex).toBeLessThan(firstFuncIndex);
 });
+
+// ============================================================================
+// UNTYPED ARROW FUNCTIONS - should not break reflection
+// ============================================================================
+
+/**
+ * Tests for untyped arrow functions that should NOT be decorated with __assignType.
+ *
+ * When an arrow function has no explicit type annotations and no parameters,
+ * the type-compiler should either:
+ * - Not decorate it at all (original behavior)
+ * - Or emit a proper function type (function returning any)
+ *
+ * The issue was that after fix #352, empty ops were converted to `any` type,
+ * but this breaks ReflectionFunction.from() which expects a function type.
+ * See: GitHub Actions CI failure on feat/next branch.
+ */
+test('runtime: untyped arrow function without parameters still works with ReflectionFunction', () => {
+    const res = transpileAndRun({
+        app: `
+            // Simulate a class with a property accessed via 'this'
+            class Container {
+                value = 42;
+
+                getFactory() {
+                    // Arrow function with no type annotations referencing 'this'
+                    return () => this.value;
+                }
+            }
+
+            const container = new Container();
+            const factory = container.getFactory();
+
+            // ReflectionFunction.from should work without throwing
+            const rf = require('@deepkit/type').ReflectionFunction;
+            const reflection = rf.from(factory);
+
+            // Should get a valid function type (with 'any' return type as fallback)
+            reflection.type.kind; // Should be ReflectionKind.function (not throw)
+        `,
+    });
+
+    // ReflectionKind.function = 17
+    expect(res).toBe(17);
+});
+
+test('runtime: untyped arrow function in provider-like pattern works', () => {
+    const res = transpileAndRun({
+        app: `
+            // This simulates the pattern used in @deepkit/app service-container:
+            // { provide: InjectorContext, useFactory: () => this.injectorContext }
+            class ServiceContainer {
+                private contextValue = 'test-context';
+
+                addProvider(config: { useFactory: () => any }) {
+                    // The injector calls ReflectionFunction.from on the factory
+                    const rf = require('@deepkit/type').ReflectionFunction;
+                    const reflection = rf.from(config.useFactory);
+                    return reflection.type.kind;
+                }
+            }
+
+            const container = new ServiceContainer();
+            // This is the pattern that was breaking
+            const result = container.addProvider({
+                useFactory: () => container['contextValue']
+            });
+
+            result;
+        `,
+    });
+
+    // ReflectionKind.function = 17
+    expect(res).toBe(17);
+});
+
+test('transform: untyped arrow function should not get invalid __assignType', () => {
+    const res = transform({
+        app: `
+            class Container {
+                value = 42;
+                getFactory() {
+                    return () => this.value;
+                }
+            }
+        `,
+    });
+
+    // The arrow function should either:
+    // 1. Not be wrapped with __assignType at all, OR
+    // 2. Be wrapped with a proper function type (not just 'any')
+    //
+    // Invalid: __assignType(() => this.value, ['"'])
+    // Valid: no __assignType, OR __assignType with proper function bytecode
+
+    // Check that if __assignType is present, it doesn't have just ['"'] (which is just 'any')
+    // The pattern ['"'] means the type is 'any', not 'function returning any'
+    const hasInvalidAnyOnlyType = res.app.includes("__assignType(() => this.value, ['\"'");
+
+    expect(hasInvalidAnyOnlyType).toBe(false);
+});

packages/type/tests/integration2.spec.ts

@@ -2168,3 +2168,42 @@ test('map as complex', () => {
     expect(type.types[0].type.types[0].type.types[0].name).toBe('thePayload');
     assertType(type.types[0].type.types[0].type.types[0].type, ReflectionKind.string);
 });
+
+test('ReflectionFunction.from() with untyped arrow function', () => {
+    // Arrow function without explicit type annotations
+    // This pattern is used in DI factory providers like:
+    // { provide: InjectorContext, useFactory: () => this.injectorContext }
+    const untypedArrowFn = () => 42;
+
+    // Should not throw - should return a valid function reflection
+    const reflection = ReflectionFunction.from(untypedArrowFn);
+
+    // Should be a function type
+    expect(reflection.type.kind).toBe(ReflectionKind.function);
+
+    // Should have no parameters (since none were declared)
+    expect(reflection.getParameters().length).toBe(0);
+
+    // Return type should be 'any' (since we couldn't infer it)
+    expect(reflection.getReturnType().kind).toBe(ReflectionKind.any);
+});
+
+test('ReflectionFunction.from() with untyped arrow function referencing this', () => {
+    class Container {
+        value = 42;
+
+        getFactory() {
+            // This pattern was breaking after #352 fix
+            return () => this.value;
+        }
+    }
+
+    const container = new Container();
+    const factory = container.getFactory();
+
+    // Should not throw - should return a valid function reflection
+    const reflection = ReflectionFunction.from(factory);
+
+    // Should be a function type (not 'any')
+    expect(reflection.type.kind).toBe(ReflectionKind.function);
+});