# RESOLVED — 0127: namespaced generic call's result mis-types as the unbound `T` stub

> **RESOLVED** (2026-06-12). Root cause: the call-PLAN producer's
> namespace-fn arms (src/ir/calls.zig, the `fn_ast_map`-backed qualified
> and bare-name fallbacks) returned the DECLARED return type — `T`,
> resolving to the unbound stub — without checking `type_params`, while
> the bare-identifier path routes generics through
> `inferGenericReturnType`. Lowering dispatched the right mono (the
> value was correct); only the planned result type was wrong, so
> pack-fn callers (print's Any boxing) mis-tagged it — and a non-i64
> binding (f64) failed LLVM verification outright, the pack being
> monomorphized for the stub while the call returned `double`. Fix:
> both arms now classify a `type_params.len > 0` callee as
> `.generic_fn` and infer the return type through the call's bindings,
> mirroring the flat path. Regression test:
> `examples/0213-generics-namespaced-call-result.sx` (i64 + f64
> bindings via print, concrete type flowing into arithmetic; pre-fix:
> `T{}` boxing / LLVM verification failure — both demonstrated).
> Gates: zig build test 426/426, suite 595/595, distribution repo
> 14/14.

## Symptom

A NAMESPACED call to a generic free function returns a value typed as the
unbound `T` empty-struct stub instead of the bound concrete type.

- **Observed**: `print("{}\n", m.pick(3, 9))` prints `T{}` — the Any boxing
  tags the result with the unbound `T` stub type.
- **Expected**: prints `9`.

The same call through a FLAT import (`pick(3, 9)`) prints `9` — only the
namespaced spelling (`field_access` callee whose object is a namespace
alias) mis-types the result.

## Reproduction

m.sx:

```sx
#import "modules/std.sx";

pick :: (a: $T, b: T) -> T {
    if a > b then a else b
}
```

main.sx:

```sx
#import "modules/std.sx";
m :: #import "m.sx";

main :: () {
    print("{}\n", m.pick(3, 9));
}
```

Observed at master 309f48e: prints `T{}`. The flat-import spelling of the
same call prints `9`.

## Investigation prompt

Suspected area: the namespaced/qualified dispatch leg in
`src/ir/lower/call.zig` `lowerCall` (the qualified `fn_ast_map` paths)
and/or the generic return-type inference not being consulted for the
namespaced callee shape. The plain-identifier path routes the call's
result typing through `buildTypeBindings` (the one binding builder —
see a47ea14's note); the namespaced path appears to stamp the declared
return type (`T`) without substituting the call's inferred bindings, so
the result carries the unbound-`T` stub struct into Any boxing.

Fix: make the namespaced generic call derive its result type from the
call's inferred `$T → concrete` bindings exactly like the flat path.
Check whether the value itself is computed correctly (the mono body) and
only the recorded result TYPE is wrong, or whether dispatch skipped
monomorphization entirely.

Verification: the repro prints `9`; the flat spelling still prints `9`;
`zig build && zig build test`, `bash tests/run_examples.sh` green; pin
the repro as a generics example (next free 02xx number).