[mitchellnemitz]

Summary

A generic function call now infers the type parameters its value arguments leave unbound from the call site's expected type. A return-only type parameter no longer has to be restated as an explicit type argument:

let xs: int[] = empty_list()      # was: empty_list[int]()

This is a type-checker-only change. The compiled shell is byte-identical to the explicit-type-argument form, so no runtime or codegen behavior changes; the only difference is that programs which previously required explicit type arguments now also compile without them.

How it works

The checker already computes an expected type and threads it to the let/final/return/assignment/array-literal/dict-literal positions. The one place that discarded it was the call-expression case in exprType. This forwards that expected type through the call chain into checkGenericUserCall, and after value arguments have bound what they can (before the cannot-infer error), unifies the callee's declared return type against the expected type to bind any still-unbound type parameter.

Precedence holds: value arguments bind first and always win; an explicit type-argument list disables context inference entirely; an expected type that itself carries an unresolved type variable is not concrete and does not drive inference. A context type that contradicts a value-argument binding reuses the existing unify-conflict error rather than a new error kind.

Inference positions

let/final binding, return, concretely-typed call argument, assignment RHS, and array-element / dict-value. Field-assignment and index-assignment RHS also infer, because those handlers already thread the target type as context; that behavior is locked by tests rather than special-cased away.

Boundaries (unchanged)

Variable, parameter, and return-type annotations stay mandatory. An unpinned type parameter is still an error (no defaulting). A nested call whose enclosing parameter is itself an unbound type variable, e.g. identity(empty_list()), still needs explicit type arguments.

Tests

• Checker tests for every position, for precedence and conflict, and for the nested-unbound and type-variable-carrying boundaries.
• Codegen byte-identity tests: context-inferred output equals the explicit-type-argument output at every position; numeric-bounded params still monomorphize (int and float outputs differ); comparable-bounded params are type-erased; bound violations still error.
• A cross-shell golden fixture with identical stdout under dash, busybox ash, bash, and zsh.
• gofmt, go vet, and go test ./... clean; the build-test and golden CI jobs pass locally under act.