fix(emit): rename local vars and params that collide with import aliases

[mickamy]

Summary

The generated code could pick a local variable or parameter name that shadows an imported package alias. When a downstream line then used the shadowed package — e.g. db.Open(...) after db, err := config.NewDB() — the call resolved against the local value instead of the package, producing a broken constructor that failed to compile.

This change adds a small renaming pass in the emitter. After imports are collected, every input and step name is checked against the set of names already taken by import aliases (and a small set of always-reserved identifiers like err); collisions are suffixed with a numeric counter (db → db2).

Trigger

The atode codebase hit this with the following shape:

type Infra struct {
    _   config.KV
    DB  *sql.DB       `inject:"with=db.Open"`
    Tx  tx.Transactor `inject:""`
    KVS kv.Client     `inject:"with=kv.New"`
}

The generated constructor imported both db (for db.Open) and kv (for kv.New) and then declared local variables also called db and kv, which immediately collided. A context.Context arg parameter similarly shadowed the context import.

Drive-by

example/returns/injector_gen.go regenerates to greeter2 := greeter.NewGreeter(). The previous output (greeter := greeter.NewGreeter()) compiled by accident — Go evaluates the RHS of := before binding the LHS — but any later reference to the package would have broken. The renamed variable is the same generation now applied consistently.

Test plan

• internal/emit: new TestEmit_VarNameDoesNotShadowImportedPackage (uses Imports.New(reserved...) to inject collision candidates and asserts the rendered body does not assign to those names)
• make lint reports 0 issues
• make test-e2e regenerates every example and passes go vet + go build

[gemini-code-assist]

Code Review

This pull request introduces a mechanism to prevent generated variable and parameter names from colliding with imported package aliases. It adds an assignNames function to resolve name collisions by appending a counter suffix and updates the code generation logic to use these collision-free identifiers. The feedback suggests optimizing this process by directly accessing the unexported im.used map within the same package, which would eliminate the need for the new Reserved() method and avoid unnecessary slice allocations.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Since assignNames and Imports are in the same package, we can directly access im.used instead of calling im.Reserved(). This avoids allocating an intermediate slice and doing a double iteration, improving both performance and memory usage.

Suggested change

	func assignNames(im *Imports, p plan.Plan) names {
	taken := map[string]bool{}
	for _, a := range im.Reserved() {
	taken[a] = true
	}
	func assignNames(im *Imports, p plan.Plan) names {
	taken := make(map[string]bool, len(im.used)+3)
	for a := range im.used {
	taken[a] = true
	}

[mickamy]

Good catch — applied in 8ec97c8. assignNames now reads im.used directly and Reserved() is removed entirely (it had no other callers). Saves one allocation per assignNames call and keeps the API surface narrower.

[gemini-code-assist]

Since assignNames is in the same emit package, it can directly access the unexported im.used map. This makes the Reserved() method obsolete. We can remove Reserved() entirely to simplify the API and avoid unnecessary slice allocations.

[mickamy]

Done in 8ec97c8 — Reserved() removed entirely from imports.go since assignNames is its only caller and now reads im.used directly.