interp/jit_plan.go (1)

108-123: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

input as a function name shadows the conventional *compileInput parameter name.

staticPlan(input *compileInput) (Line 198) and likely other functions in this file take a *compileInput parameter also named input, which now shadows the package-level input() constructor within those scopes. It compiles fine today, but it's confusing to read and would silently break if any of those functions ever needed to call the constructor.

♻️ Suggested rename to avoid the collision

-func input(i *Interpreter, addr int) (*compileInput, bool) {
+func newInput(i *Interpreter, addr int) (*compileInput, bool) {

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@interp/jit_plan.go` around lines 108 - 123, Rename the package-level input
constructor to a distinct name and update every call site, including staticPlan
and any other references, so it no longer collides with *compileInput parameters
named input.

interp/jit_arm64.go (1)

870-891: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Ref-kind localLoaded clear happens before loadLocal's success is known.

f.state[idx] &^= localLoaded runs unconditionally for KindRef locals before l.loadLocal(...) is called and checked. Today loadLocal cannot fail for KindRef (its only internal failure branch is gated on KindI64), so this is currently safe, but it violates the stated invariant that failed lowering must not mutate frame facts, and would silently break if a Ref-specific failure path is ever added to loadLocal.

🛡️ Defensive reordering

 func (l arm64Lowerer) localGet(ctx *lowering, op step) bool {
 	f := ctx.frame()
 	idx := int(op.args[0])
 	if idx >= len(f.kinds) {
 		return false
 	}
-	if f.kinds[idx] == types.KindRef {
-		f.state[idx] &^= localLoaded
-	}
 	if !l.loadLocal(ctx, f, idx, op.ip) {
 		return false
 	}
+	if f.kinds[idx] == types.KindRef {
+		f.state[idx] &^= localLoaded
+	}

Based on learnings, this is not tied to a specific retrieved-learning note; the concern is grounded directly in the interp/**/*.go coding guideline on JIT handler mutation-on-failure.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@interp/jit_arm64.go` around lines 870 - 891, Move the Ref-local f.state[idx]
&^= localLoaded mutation in arm64Lowerer.localGet to occur only after
l.loadLocal succeeds. Preserve the existing early return on loadLocal failure so
failed lowering leaves frame facts unchanged, while retaining the current
reference-retention and push behavior on success.

Source: Coding guidelines

analysis/gvn.go (1)

109-109: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Place newNumbering after its caller.

Run calls newNumbering, but newNumbering is declared earlier in the file. Move the helper below Run so callers precede callees.

As per coding guidelines, callers must be declared before callees.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@analysis/gvn.go` at line 109, Move the newNumbering function declaration
below Run in analysis/gvn.go, leaving its implementation unchanged so the caller
appears before the callee.

Source: Coding guidelines

transform/cd_test.go (1)

66-84: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Exercise type deduplication and remapping here.

This case omits MAP_NEW and uses unique type indices, so it would pass even if the new scan or rewrite logic failed to remap operands. Add duplicate ref/map types and assert the compacted type table plus rewritten indices.

Suggested coverage update

 		{
 			name: "all type operands",
 			program: program.New(
 				[]instr.Instruction{
 					instr.New(instr.REF_TEST, 0),
-					instr.New(instr.REF_CAST, 1),
-					instr.New(instr.MAP_NEW_DEFAULT, 2),
+					instr.New(instr.REF_CAST, 0),
+					instr.New(instr.MAP_NEW, 1),
+					instr.New(instr.MAP_NEW_DEFAULT, 1),
 				},
 				program.WithTypes(
-					types.TypeString, types.TypeError, types.NewMapType(types.TypeI32, types.TypeI32),
+					types.TypeString,
+					types.NewMapType(types.TypeI32, types.TypeI32),
 				),
 			),
 			expected: program.New(
 				[]instr.Instruction{
 					instr.New(instr.REF_TEST, 0),
-					instr.New(instr.REF_CAST, 1),
-					instr.New(instr.MAP_NEW_DEFAULT, 2),
+					instr.New(instr.REF_CAST, 0),
+					instr.New(instr.MAP_NEW, 1),
+					instr.New(instr.MAP_NEW_DEFAULT, 1),
 				},

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@transform/cd_test.go` around lines 66 - 84, Update the “all type operands”
case in the transform tests to include duplicate reference and map types,
including MAP_NEW, so deduplication and operand remapping are exercised. Assert
the expected compacted type table and rewritten indices for REF_TEST, REF_CAST,
MAP_NEW_DEFAULT, and MAP_NEW rather than retaining unique indices.

asm/regalloc.go (1)

109-113: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Remove or wire the unused block helper.

golangci-lint reports (*allocator).block as unused at Line 109. Unless a generated or build-tagged caller is intentionally omitted, delete this dead helper or add the missing call path.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@asm/regalloc.go` around lines 109 - 113, Remove the unused allocator.block
method unless a valid generated or build-tagged caller is required; otherwise
wire it into the intended register-blocking path. Verify references to
(*allocator).block and preserve the existing blocked and avail updates wherever
that behavior is needed.

Source: Linters/SAST tools

program/verify.go (1)

81-108: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

newChecker is defined before its caller Verify.

Elsewhere in this file callers consistently precede their callees (step→call, merge→unify, step→acceptsType), but here newChecker (81) is defined above Verify (93), which calls it. As per coding guidelines, **/*.go files should place "callers before callees."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@program/verify.go` around lines 81 - 108, Reorder the declarations in
program/verify.go so Verify appears before newChecker, keeping both
implementations and behavior unchanged. Verify should remain the caller and
newChecker its following callee, matching the file’s callers-before-callees
convention.

Source: Coding guidelines

interp/interp.go (1)

1790-1821: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Remove unused globalKinds() interp/interp.go:1790-1807 can be dropped.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@interp/interp.go` around lines 1790 - 1821, Remove the unused
Interpreter.globalKinds method from interp/interp.go. Leave globalReprs and all
other global-kind handling unchanged.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes