fix(@typegpu/gl): Evaluate the right-hand side of an aliasing const once

[dchaudhari7177]

Fixes #3029.

Cause

For const value = values[nextIndex()]!; the GLSL generator evaluated the right-hand side three times:

1. WgslGenerator._constStatement evaluates eqNode to decide the declaration kind. It lands in _aliasConstStatement because the value aliases a local array.
2. #hoistIndexAccesses evaluates each index again to decide whether to hoist it. For a comptime index it keeps the original call node, since the result is constant.
3. this._expression(...) over the rewritten access evaluates that call node a third time.

nextIndex() ran on each pass, and only the last result reached the output, so the shader read values[2].

Fix

GlslGenerator now overrides _constStatement and _expression. While a const is generated, each node of its right-hand side keeps the snippet it evaluated to the first time, keyed by the node object. The hoisting walk and the final resolution get those snippets back instead of re-running the code.

• Only the RHS tree is cached. collectObjectNodes(eqNode) records the nodes up front, and _expression consults the cache only for those. A shellless function body generated while evaluating the RHS can be evaluated again with other argument types, so its nodes must not be cached. Nested const statements save and restore the previous cache.
• Identifiers are strings, so they are never cached. Evaluating one has no side effects, and the hoisted idx names are new identifiers that must resolve to their new definitions.
• The nodes #hoistIndexAccesses creates are new arrays, so they are evaluated normally. Their children are the original nodes and come from the cache.

The WGSL generator does not re-evaluate the RHS in _aliasConstStatement, so it has no such problem, and this change stays inside @typegpu/gl.

Tests

Two cases added to packages/typegpu-gl/tests/implicitPointer.test.ts. Each asserts the generated GLSL and calls === 1:

• The snippet from the issue now resolves to return values[0].x;.
• A runtime index with a comptime part, boids.$[nextIndex() + index], hoists to int idx = (0 + index);. The comptime part runs once, and the runtime part is still hoisted to the declaration point.

$ npx vitest run            # packages/typegpu-gl
Test Files  8 passed (8)
     Tests  75 passed | 2 skipped (77)

With only src/glslGenerator.ts reverted, both new tests fail and the other 7 in the file pass.

Also ran:

• tsc --p ./tsconfig.json --noEmit and tsc --p ./tsconfig.test.json --noEmit for @typegpu/gl: clean.
• oxlint -c oxlint.config.ts --max-warnings=0 --type-aware on both files: 0 warnings.
• oxfmt --check on both files: clean.

I did not run the full monorepo pnpm test. The install here was filtered to @typegpu/gl and its dependencies, and no test outside packages/typegpu-gl imports it.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[pullfrog]

✅ No new issues found.

Reviewed changes

• RHS single-evaluation for aliasing consts — GlslGenerator now overrides _constStatement and _expression to memoize each right-hand-side node's snippet, so #hoistIndexAccesses and the final resolution reuse the first evaluation instead of re-running comptime code with side effects.
• collectObjectNodes helper — records every array/object node in the RHS tree up front; identifiers (strings) are deliberately excluded so hoisted idx names still resolve to their new definitions.
• Nested-const safety — the active cache is saved and restored around super._constStatement via try/finally, and only RHS nodes are cached so shellless function bodies can still be regenerated with different argument types.
• Two regression tests — implicitPointer.test.ts covers the exact issue snippet (values[0].x, calls === 1) and a hoisted runtime index with a comptime part (int idx = (0 + index);, calls === 1).

I verified both new tests fail against the pre-fix generator (they produced values[2].x and (1 + index)), so they genuinely pin the bug. The full @typegpu/gl suite and pnpm --filter @typegpu/gl test:types pass locally. The fix is correctly scoped to GLSL, since the WGSL _aliasConstStatement does not re-evaluate the RHS.

  ^{｜ View workflow run ｜ Using DeepSeek Flash (free via Pullfrog for OSS) ｜ 𝕏}

[Abhirup0]

Nice fix. Confining the RHS memoization strictly to GlslGenerator makes sense given that WGSL doesn't need to rewrite the AST for aliases.

A couple of quick checks on the implementation:

1. The stack restoration via previous = this.#constRhs in _constStatement is clean, but could we add a test for a case where comptime evaluation inside a const RHS executes another const declaration? That would give coverage for the stack handling in try/finally.
2. Have you verified multi-dimensional access (e.g. grid[nextA()][nextB()])? Adding a case with two comptime indices on a nested structure would help ensure recursive hoisting handles the cached sub-nodes cleanly.

Other than those two test cases, the logic and scoping look solid to me.

[dchaudhari7177]

Thanks @Abhirup0, both are good cases. Added in 7d218e0:

1. Nested const inside a const RHS. main has const boid = boids.$[pick() + nextIndex()]!, and pick is a 'use gpu' function with its own aliasing const value = values[nextIndex()]!. So generating the outer RHS generates pick's body, which runs _constStatement again. nextIndex runs exactly twice (0 inside pick, 1 outside), and the outer index resolves to pick() + 1. I checked that this test guards the stack: replacing this.#constRhs = previous in the finally with = undefined fails this test and nothing else.
2. Two comptime indices on a nested array. grid.$[nextRow() + row]![nextCol() + col]! on an arrayOf(arrayOf(Boid, 4), 4) hoists both levels to idx / idx_1, with each comptime function called once.

Against main's glslGenerator.ts all four tests from this PR fail. On the branch, implicitPointer.test.ts gives 11 passed, and oxfmt is clean.

[pullfrog]

✅ No new issues found.

Reviewed changes

Review of the one commit added since the prior Pullfrog review (7d218e08e, test-only). Both new cases cover the scenarios raised in the human review and are meaningful — neutralizing the _constStatement/_expression overrides makes each of them fail.

• Nested-const cache restore test — boids.$[pick() + nextIndex()], where pick() declares its own aliasing const, asserts int idx = (pick() + 1); and calls === 2, pinning the save/restore of #constRhs across a nested _constStatement. Pre-fix it emits pick() + 2.
• Two-level hoisted access test — grid[nextRow() + row]![nextCol() + col]! asserts int idx = (0 + row); int idx_1 = (0 + col); with rowCalls === 1 and colCalls === 1, exercising recursive #hoistIndexAccesses over multiple cached comptime indices. Pre-fix it emits (1 + row) / (1 + col).

pnpm vitest run tests/implicitPointer.test.ts → 11 passed. No new issues.

  ^{｜ View workflow run ｜ Using deepseek-v4.1-flash (free via Pullfrog for OSS) ｜ 𝕏}