fix(gxt-backend): refresh state.currentGetter on pool reuse so child each-rows see new args

When a parent component force-rerenders, its inner {{#each}} block builds a
fresh template subtree into a temp container that is later morphed onto the
live DOM. Each iteration claims a child component from the pool. The pool
match (by row identity or position) was correct, but the descriptor's
rcGet closure captured a getter from the FIRST createRenderContext call —
so `this.item` returned stale row data after the parent re-rendered.

Two fixes, both targeting the WeakMap state that survives descriptor
replacements:

1. updateInstanceWithNewArgs now updates state.currentGetter alongside
   argGetters[key], so the rcGet closure's `g = state.currentGetter`
   read sees the fresh per-row arg getter even when the descriptor lost
   its __gxtRenderCtxArgGetter marker (e.g., via an upstream cellFor
   reinstall) and createRenderContext's fast path is skipped.

2. createRenderContext's fast and slow paths both refresh state.currentGetter
   (slow path was relying on the closure-captured `getter`, which is frozen
   to the first install). The rcGet now reads `state.currentGetter || getter`
   so the latest per-row getter wins.

Fixes 4 of the 7 remaining smoke failures:
  - Components test: curly components / non-block with each rendering child components
  - Syntax test: {{#each}} with native arrays / updating and setting within #each
  - Syntax test: {{#each}} with emberA-wrapped arrays / updating and setting within #each
  - Syntax test: {{#each}} with array proxies, * / updating and setting within #each (4 variants)

The remaining 3 failures (DOM node stability for stable keys when list
is updated) have a different root cause — morph-based fresh template
render doesn't preserve DOM identity for keyed each items — and are
left for a follow-up.

Smoke results: 330/333 (was 326/333). No regressions.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: lifeart

packages/@ember/-internals/gxt-backend/manager.ts

@@ -194,18 +194,21 @@ let emberViewIdCounter = 0;
 //   useLocal: whether to return localVal vs. the arg getter
 // This survives createRenderContext re-invocations even when the descriptor
 // is replaced by cellFor(obj, key, false) or other reactive reinstallers.
-const _rcArgState = new WeakMap<object, Map<string, { localVal: any; useLocal: boolean }>>();
+const _rcArgState = new WeakMap<
+  object,
+  Map<string, { localVal: any; useLocal: boolean; currentGetter?: (() => any) | null }>
+>();
 function _getRcArgState(
   instance: object,
   key: string
-): { localVal: any; useLocal: boolean } | undefined {
+): { localVal: any; useLocal: boolean; currentGetter?: (() => any) | null } | undefined {
   const m = _rcArgState.get(instance);
   return m ? m.get(key) : undefined;
 }
 function _setRcArgState(
   instance: object,
   key: string,
-  state: { localVal: any; useLocal: boolean }
+  state: { localVal: any; useLocal: boolean; currentGetter?: (() => any) | null }
 ): void {
   let m = _rcArgState.get(instance);
   if (!m) {
@@ -2203,6 +2206,22 @@ function updateInstanceWithNewArgs(instance: any, args: any): boolean {
       // instance's reactive getter would read from the stale old closure.
       if (newGetter && argGetters && key !== 'elementId' && key !== 'id') {
         argGetters[key] = newGetter;
+        // Also update the createRenderContext WeakMap state's currentGetter slot
+        // so that descriptor-bound rcGet closures (which read from
+        // state.currentGetter) see the new arg getter on the next read. This
+        // is critical for force-rerender of {{#each}} block bodies where the
+        // child's instance is pool-reused; createRenderContext's fast-path may
+        // not re-enter (e.g., when an upstream cellFor removed the marker on
+        // its descriptor), but the WeakMap state survives across descriptor
+        // replacements and is what rcGet's closure references.
+        try {
+          const _stateForGetter2 = _getRcArgState(instance, key);
+          if (_stateForGetter2) {
+            _stateForGetter2.currentGetter = newGetter;
+          }
+        } catch {
+          /* ignore */
+        }
         // Check if there's already a render-context-installed descriptor with
         // local-override state (from a previous createRenderContext call). If
         // so, skip reinstalling to preserve the local override (e.g., after
@@ -5316,6 +5335,23 @@ function createRenderContext(instance: any, args: any, fw: any, owner: any): any
               lastArgValue: getter(),
               ...(_savedOverride ? { initOverridden: true } : {}),
             };
+            // Fix: the descriptor's rcGet reads from `state.currentGetter` on
+            // the WeakMap state. Update it to the latest getter so that reads
+            // during force-rerender (which builds a fresh outer template and
+            // re-invokes each-row child components with new arg closures) see
+            // the new value. Without this, the descriptor's closure holds the
+            // original getter from the FIRST createRenderContext call, and
+            // `this.item` returns stale row data after the parent re-renders.
+            // See also: updateInstanceWithNewArgs, which performs the same
+            // refresh up-front so the fix is robust even when an upstream
+            // cellFor reinstall has stripped the __gxtRenderCtxArgGetter
+            // marker (in which case this fast path is skipped entirely).
+            if (instance) {
+              const _stateForGetter = _getRcArgState(instance, key);
+              if (_stateForGetter) {
+                _stateForGetter.currentGetter = getter;
+              }
+            }
           } catch {
             /* ignore */
           }
@@ -5574,7 +5610,14 @@ function createRenderContext(instance: any, args: any, fw: any, owner: any): any
             // descriptor is replaced (e.g. by cellFor(obj, key, false) called
             // elsewhere during the same render pass). The WeakMap survives.
             const existingState = instance ? _getRcArgState(instance, key) : undefined;
-            const state = existingState || { localVal: initialVal, useLocal: false };
+            const state = existingState || { localVal: initialVal, useLocal: false, currentGetter: getter };
+            // Always refresh the currentGetter slot so the rcGet closure reads
+            // the latest arg getter (the per-row closure for #each iterations).
+            // The slow path runs on first install AND when the descriptor was
+            // replaced (e.g., by an upstream cellFor reinstall) — both need a
+            // fresh getter. The fast-path skip above keeps state.currentGetter
+            // in sync for subsequent createRenderContext re-invocations.
+            state.currentGetter = getter;
             if (!existingState && instance) _setRcArgState(instance, key, state);
             const rcGet: any = function () {
               try {
@@ -5589,7 +5632,9 @@ function createRenderContext(instance: any, args: any, fw: any, owner: any): any
               } catch {
                 /* noop */
               }
-              return state.useLocal ? state.localVal : getter ? getter() : state.localVal;
+              if (state.useLocal) return state.localVal;
+              const g = state.currentGetter || getter;
+              return g ? g() : state.localVal;
             };
             rcGet.__gxtRenderCtxArgGetter = true;
             const rcSet = function (v: any) {