[WIP] evmc VM

[pdrobnjak]

Describe your changes and provide context

Testing performed to validate your change

[github-actions]

The latest Buf updates on your PR. Results from workflow Buf / buf (pull_request).

Build	Format	Lint	Breaking	Updated (UTC)
✅ passed	✅ passed	✅ passed	✅ passed	Jan 2, 2026, 2:32 PM

In general, to fix useless assignments, either (a) remove them (and possibly the surrounding code) if they are not needed, or (b) refactor the code so that the computed values are actually used. For Go, if you only need side effects from a call and not its return values, you should call the function without assigning its results, or assign unwanted results to _.

For this function, the best minimal fix that preserves existing behavior is to remove the unused local variables inside the switch and keep only the calls for their side effects. Currently, after the if flag { ... } block, the function always runs h.vm.Execute and returns based on that, completely ignoring any ret, leftoverGas, err, or createAddr produced by h.evm.* calls. Therefore, we can change each case arm to simply call the corresponding h.evm.* method without capturing its return values. This eliminates the useless assignments while leaving side effects and control flow unchanged.

Concretely, in giga/executor/vm/evmc/host_context.go within HostContext.Call, edit lines 156–166 so that each case invokes the EVM methods without := bindings. No new imports or helper methods are required.

In general, to fix a “useless assignment to local variable” you either (a) remove the assignment (and possibly the variable) if it is genuinely unused, or (b) change the code so the assigned value is actually used (for example, by returning it, logging it, or passing it to another call). Using _ is appropriate only when you intentionally ignore some returns while still needing others.

For this function, the entire if flag { switch kind { ... } } block is currently dead in terms of observable behavior: none of the variables assigned within it influence the final return values, and there’s no side effect unique to those assignments. The cleanest way to fix the issue without changing current behavior is to remove that block entirely. The remaining logic, which calls h.vm.Execute(...), already determines the function’s output and is the only active path.

Concretely:

• In giga/executor/vm/evmc/host_context.go, in func (h *HostContext) Call(...), remove the flag := true declaration, the if flag { ... } block, and the enclosed switch with its case branches.
• Keep the // ELSE comment and the subsequent evmRevision, delegated, code, and Execute call unchanged, so functional behavior remains the same as before (since the removed block had no effect).

No new methods or imports are required; we’re only deleting unused assignments and their enclosing control flow.

---

In general, to fix “useless assignment to local variable” issues, you either (1) remove the assignment if the value is never needed, or (2) replace the variable with the blank identifier _ to preserve the side-effecting call while explicitly discarding the result. Here, the Call method invokes several h.evm.* methods in a switch and assigns their multiple return values to local variables (ret, leftoverGas, createAddr, err), but those locals are never used. We want to keep the h.evm.* calls (for their side effects and correctness) while avoiding unused variables.

The best fix without changing current functionality is to change each short variable declaration in the switch from a full tuple of named variables to a set of blank identifiers, since none of the results are used later. For example, change ret, leftoverGas, err := h.evm.Call(...) to _, _, _ = h.evm.Call(...) (or just _, _, _ := h.evm.Call(...); assignment vs declaration doesn’t matter here as the variables are discarded). Similarly, for the Create and Create2 calls that return four values, use _, _, _, _ = .... This keeps the calls and their side effects intact, removes the unused err and other locals, and eliminates the CodeQL warning. No new imports or additional methods are needed; all changes are confined to the Call method in giga/executor/vm/evmc/host_context.go.

---

In general, when you must call a function but don’t need some or all of its return values, you should assign the unwanted results to the blank identifier _ rather than to named variables. This makes it explicit that the values are intentionally ignored and avoids “useless assignment” warnings.

For this specific HostContext.Call implementation in giga/executor/vm/evmc/host_context.go, the behavior after the if flag block is already determined solely by the later h.vm.Execute call. To preserve existing behavior while fixing the CodeQL warning, we should:

• Keep the calls to h.evm.Call, DelegateCall, CallCode, Create, and Create2 exactly as they are (to preserve any side effects), but
• Replace the assignments to local variables (ret, leftoverGas, err, createAddr, endowment) with assignments to _.

Concretely, on lines 157–165:

• Change ret, leftoverGas, err := ... to _, _, _ := ....
• Change ret, createAddr, leftoverGas, err := ... to _, _, _, _ := ....
• Change ret, createAddr, leftoverGas, err := h.evm.Create2(caller, code, gas, endowment, salt) so that all returned values are assigned to _ (you may need to match the actual signature; based on the existing code, keep the same arity and use _ for each position).

No imports, type definitions, or additional methods are required; we are only changing how existing function return values are bound to local variables.

In general, to fix “useless assignment to local variable” you either (1) remove the assignment entirely if the called function has no required side-effects, or (2) keep the call but ignore return values explicitly using the blank identifier _ so that no named-but-unused locals are created. Here, the intent seems to be to keep the h.evm.* calls inside the switch, but the results are not yet integrated; thus we should keep the calls (to preserve any side effects) and discard all return values explicitly.

The single best way to fix this without altering current functionality is to replace each short declaration of ret, leftoverGas, err (and createAddr) with assignment to _. For example, change:

ret, leftoverGas, err := h.evm.Call(caller, addr, input, gas, value)

to:

_, _, _ := h.evm.Call(caller, addr, input, gas, value)

and similarly for DelegateCall, CallCode, Create, and Create2, matching the exact number of returned values from those functions. This preserves all calls (and therefore side effects) but makes it explicit that their results are intentionally unused, eliminating the useless local variables and the CodeQL warning. All changes occur in giga/executor/vm/evmc/host_context.go within the shown Call method; no new imports or helper methods are required.

Generally, to fix this issue you either (a) remove dead assignments entirely, or (b) if you must call the function for its side effects but don’t use some or all return values, assign those to the blank identifier _ instead of named locals. This prevents creation of unused variables and makes the intent explicit.

For this specific HostContext.Call method in giga/executor/vm/evmc/host_context.go, we want to preserve the call to the underlying h.evm.* methods (in case they have side effects) but avoid introducing unused local variables ret, leftoverGas, createAddr, and err. The simplest change is:

• In each case of the switch kind (lines 156–165), replace ret, leftoverGas, err := ... with _, _, _ = ... and ret, createAddr, leftoverGas, err := ... with _, _, _, _ = .... This keeps the calls while discarding all return values.
• Do not touch the later executionResult, err := h.vm.Execute(...) or its subsequent if err != nil block, since that is the err actually used for control flow.
• No new imports or helper functions are needed.

This keeps existing behavior (still calling the h.evm.* methods when flag is true) while eliminating the useless assignments that CodeQL flagged.

In general, to fix a “useless assignment to local variable” where a function is called only for side effects and the return values are intentionally ignored, you should replace the named variables with the blank identifier _. This keeps the call and its side effects, while making it explicit that the results are unused and eliminating unused‑variable warnings.

Here, inside HostContext.Call, for each case in the switch kind, we should keep the calls to h.evm.Call, DelegateCall, CallCode, Create, and Create2 (assuming they are needed for side effects) but stop assigning their return values to named locals that are never read. The minimal, behavior‑preserving change is to replace e.g.:

ret, leftoverGas, err := h.evm.Call(...)

with:

_, _, _ = h.evm.Call(...)

and similarly for the other cases, using the appropriate number of _ placeholders. This change is entirely local to giga/executor/vm/evmc/host_context.go within the Call method’s switch block, and it does not require any new imports or type changes.

In general, to fix "useless assignment to local variable" you either (1) remove the unused variable and its assignment, or (2) if the value must be computed for side effects, assign it to the blank identifier _ for any parts that are intentionally unused. Here, createAddr is returned by h.evm.Create / Create2 but not used anywhere, while the function’s public API already has a dedicated return slot for the create address (4th return value), which is currently always evmc.Address{}. The cleanest fix, without changing existing external behavior, is to stop binding the unused result to a named variable and instead assign it to _. This preserves the function calls and their side effects while eliminating the unused local variable.

Concretely, in giga/executor/vm/evmc/host_context.go within HostContext.Call, change the Create and Create2 cases so that they use _ instead of createAddr in the multiple assignment from h.evm.Create and h.evm.Create2. No other logic or return values are altered, and you do not need any new imports or helper methods.

In general, to fix a "useless assignment to local variable" where a value is never read, you either remove the variable from the assignment list or eliminate the whole statement if all assigned variables are unused. If you must still call the function for its side effects but do not need some return values, you can assign them to the blank identifier _ instead of naming them, or ignore all results.

In this specific function, the if flag { ... } block does not affect the function’s return values or control flow: flag is always true, but everything inside the switch only declares case-local variables that are never read. The real execution and returned values come from the later h.vm.Execute call. The cleanest fix that doesn’t change visible behavior is to remove the entire if flag { ... } block (including the flag := true line), because it is dead code and the methods (h.evm.Call, DelegateCall, etc.) are not contributing to the result. This automatically removes the unused leftoverGas definition (line 165) and the other unused locals.

Concretely, in giga/executor/vm/evmc/host_context.go, in the Call method, delete lines 153–167:

• Remove flag := true.
• Remove the if flag { ... } block and its switch kind with the h.evm.* calls.

No new imports, methods, or definitions are needed, and the rest of the function (the // ELSE section starting at line 169) remains unchanged.

In general, to fix "useless assignment to local variable" issues, remove assignments whose results are never read, or, if you only need side effects, avoid binding the returned values. In this case, the entire flag/switch block only assigns to local variables (ret, leftoverGas, err, createAddr) that are never used, and the branch is guarded by a constant flag := true, so the block is always executed but has no effect on the returned values.

The best fix that preserves existing observable behavior is to remove this dead if flag { switch ... } block entirely. Currently, the function's behavior is fully determined by the later h.vm.Execute call and its error handling; removing the dead code does not change that. Specifically, in giga/executor/vm/evmc/host_context.go, lines 152–167 (the flag := true declaration, the if flag { and the entire switch kind { ... } body, and the closing brace) should be deleted, leaving the // ELSE comment and subsequent Execute call untouched. No new imports, methods, or definitions are required.