Repository navigation
ENG-12682 Let React Compiler optimize generated components - #7272
FarhanAliRaza wants to merge 4 commits into
Conversation
Generated code hit React Compiler bailouts that Reflex controls: render-time writes to the shared refs registry, `useMemo(generateUUID, [])`, module imports and unused hook bindings listed as useCallback dependencies, and outlined rest-parameter event handlers. Emotion's `jsx()` calls were also opaque to the compiler, so compiled components could not cache elements per input. - Register id refs through a `useRegisteredRef` hook in utils/state.js. - Pass `useMemo` an inline callback for generated UUIDs. - List only referenced bindings as useCallback dependencies. - Pin the experimental compiler, disable function outlining, and describe Emotion's `jsx` via `moduleTypeProvider`. - Add `auto_memoize` (default True) so apps using `react_compiler` can let the compiler memoize whole pages instead of generated memo wrappers.
|
Merging this PR will not alter performance
Comparing Footnotes
|
There was a problem hiding this comment.
All reported issues were addressed across 20 files
Reply with feedback, questions, or to request a fix.
Re-trigger cubic
There was a problem hiding this comment.
All reported issues were addressed across 10 files (changes from recent commits).
Reply with feedback, questions, or to request a fix.
Re-trigger cubic
…-generation tests/units/reflex_base/templates/test_vite_plugin_react_compiler.py: kept the PR's emotion jsx module-type test and the base's prebundle/prod-react merge test. tests/units/reflex_base/vars/test_base.py: kept the PR's useMemo inline-callback test and the base's reserved-name/state-root tests. tests/units/test_prerequisites.py: took the base's assertion derived from REACT_COMPILER_DEV_DEPENDENCIES, which covers the PR's pinned compiler version. Claude-Session: https://claude.ai/code/session_01VDzz2un9mtjmCY24zSGmca
Client state with Unicode names is not an event handler kind; say what the change does for it instead of listing it under memoized handlers. Claude-Session: https://claude.ai/code/session_01VDzz2un9mtjmCY24zSGmca
* Let React Compiler optimize generated components Replays #7272 onto main. That PR auto-closed when its base branch was deleted after #7234 merged; its own changes were the diff between the base-branch head it last merged (07aa53c) and its head (4f3e5db), covering commits c01f4d4, 755ddba and 4f3e5db. Change the patterns Reflex emits that made React Compiler bail out: register refs through a useRegisteredRef hook instead of writing to refs during render, wrap generateUUID in an inline useMemo callback, list only referenced bindings as useCallback dependencies, disable function outlining, and describe Emotion's jsx() to the compiler as JSX. Pin the experimental compiler, which accepts refs passed to jsx(). Add an auto_memoize config option (default True). False removes MemoizeStatefulPlugin from page compilation so the compiler memoizes whole pages; app-root memoization is unchanged. Conflicts with main: #7586 removed hook positions, so the ref hook no longer passes VarData(position=INTERNAL); #7435 removed backend_state_mismatch from state.js, so it stays removed. Claude-Session: https://claude.ai/code/session_01LwJUCTv3FVWzi1UoUpyMLT * Tie the callback prune pattern to Python names, tidy tests and fragment Export GENERATED_EVENT_CALLBACK from the React Compiler adapter and test it against the names get_memoized_event_triggers produces, so a rename on either side fails a test instead of silently restoring compiler bailouts. Drop the Unicode stale-callback claim from the reflex-base fragment: main never had that bug. Move inline test imports to module level. * Run the auto_memoize compile_app test as a dry run Without dry_run, REFLEX_SKIP_COMPILE or a leftover .web/nocompile file made compile_app return before building the page plugins, and the test wrote into the working directory's .web. * Derive the client counter test's JS from the var's real identifier (#7741) test_memo_client_counter hard-coded the JavaScript name a client state var binds its value to ("Δcounter + 1"). Merging main brought in #6936, which drops the name of a legacy ClientStateVar created with global_ref=False and suffixes the emitted identifier with RxClientState, so the hook now reads `const [cs$0RxClientState, setCs$0] = ...` while the click handler still read `Δcounter`. That bare identifier resolved to the button carrying id="Δcounter" through the browser's named element access, and the counter rendered "[object HTMLButtonElement]1". Build the increment expression from str(counter.value) instead, with a {value} placeholder for the direct read and a {source} placeholder for the eval'd reads, so the test follows whatever identifier Reflex emits. Use rx.client_state(0) and .set(...) in place of the deprecated ClientStateVar.create / set_value entry points. rx.client_state rejects non-ASCII names, so the Unicode case becomes a plain scoped counter; test_react_compiler_callback_dependencies still covers Unicode bindings in the Babel dependency prune. Claude-Session: https://claude.ai/code/session_01ESN8Dfnc4fUrUVcPsqaLGk Co-authored-by: Claude <noreply@anthropic.com> * Keep lifecycle events in their branch when auto_memoize is off Without memo wrappers, on_mount and on_unmount hooks were hoisted to the page function. A hidden rx.cond branch fired on_mount on page load, and an rx.foreach item hook read the loop variable outside the loop. Render the events as a MountEffect element beside the component instead. * Warn once that react_compiler is experimental * Render lifecycle events as elements in every compile mode An on_mount inside rx.foreach was hoisted to the Foreach memo body, where the loop variable does not exist, so the page crashed. Run InlineLifecyclePlugin with auto-memoization on as well, and rewrite a snapshot subtree before the memoize plugin seals it. * Limit the lifecycle element plugin to the experimental options Default apps keep the generated code they have on main. The plugin runs with react_compiler=True or auto_memoize=False. * Keep scope wrappers when auto_memoize is off; remove MountEffect The MountEffect element kept one instance across an rx.cond branch switch, so no lifecycle event fired, and its fragment hid the child from an as_child parent. With auto_memoize=False, still wrap a component that has a lifecycle event or hooks of its own in a memo component. A wrapper has its own identity and forwards props, and it keeps the hooks in their rx.cond branch. * Test rx.foreach item lifecycle with auto_memoize off; complete the docstring - An item's lifecycle hook compiles into a wrapper inside the loop body and receives the loop variable when auto_memoize is off. - default_page_plugins names the snapshot boundary and ALWAYS exceptions. Claude-Session: https://claude.ai/code/session_01LwJUCVweoEhh1JsZA7emsa * Keep lifecycle of prop components in a wrapper when auto_memoize is off With auto_memoize off, a lifecycle event of a component held in a prop moved into the page function, so it fired on page load even inside a hidden rx.cond branch. The scope-only rule now uses _has_instance_hooks, which also checks components held in props. Claude-Session: https://claude.ai/code/session_01LwJUCVweoEhh1JsZA7emsa --------- Co-authored-by: Masen Furer <m_github@0x26.net> Co-authored-by: Claude <noreply@anthropic.com>
Stacked on #7234.
React Compiler bailed out on most generated pages and memo wrappers because of patterns Reflex emits. This PR changes those patterns. It also adds an
auto_memoizeoption, so an app usingreact_compilercan let the compiler memoize whole pages instead of Reflex's generated memo wrappers.Changes
refs["ref_x"] = ref_xduring render ("This value cannot be modified")const ref_x = useRegisteredRef("ref_x"). The hook lives inutils/state.js, outside compiler scope, and keeps the same registry behavior.useMemo(generateUUID, [])("Expected the first argument to be an inline function expression")useMemo(() => generateUUID(), [])useCallbackdeps listaddEvents,ReflexEvent, and unused hook bindings such assetFilesById("Found extra memoization dependencies")(...args) => addEvents(...)handlers crash function outlining ("Expected temporaries to be promoted")enableFunctionOutlining: falsejsx(type, props, ...children)from Emotion is an unknown function, so compiled pages cannot cache elements (33 vs 280 cache slots on the test dashboard)moduleTypeProviderdescribingjsxlike JSX syntax: frozen arguments, frozen resultThe experimental compiler (
0.0.0-experimental-a1856f3-20260507) is required. 1.0.0 still rejects refs passed tojsx()and optional calls in ternary tests.auto_memoize=FalseremovesMemoizeStatefulPluginfrom page compilation. App-root memoization is unchanged.Measurements
Production builds, Chromium, direct state dispatch, 11 alternating rounds × 100 updates. Dashboard page: sidebar, 8 KPI cards, two Recharts charts, tabs with a form and a 10-item list, static cards.
react_compilerreact_compiler+auto_memoize=FalseCompiler page coverage with
auto_memoize=False: 17/17 stateful pages in a feature fixture, plus 7/8 in a built-in component sweep. The sweep covers Radix, markdown, code, data editor, gridjs, Recharts, Plotly, moment, and event patterns.rx.auto_scrollstill bails because its hook code mutates a ref value in render-scope helpers. The app-root Toaster still writesrefs['__toast']during render, and it renders once.Python compile time with auto-memo off:
Validation
rx.set_focus, controlled input round trip, and backend events. The rendered DOM is identical between compiler variants.Known limits
auto_memoize=False, a page the compiler skips re-renders fully on every state change, about 2× slower than today. The docs say to measure before turning it off.