Dedup auto-memoize passthrough definitions during compile

[Alek99]

All Submissions:

• Have you followed the guidelines stated in CONTRIBUTING.md file?
• Have you checked to ensure there aren't any other open Pull Requests for the desired changed?

Type of change

• Performance improvement (non-breaking change, identical compile output)

Changes To Core Features:

• Have you added an explanation of what your changes do and why you'd like us to include them?
• Have you written new tests for your core changes, as applicable?

What this does

The auto-memoize plugin (MemoizeStatefulPlugin) built a full memo definition for every stateful call site and only deduped by (tag, source_module) afterwards. In profiling of a 500-duplicated-row page this was ~56% of compile CPU: 1,001 definitions were built and then collapsed to 3 unique ones. Per call site it:

1. ran _analyze_params twice on a constant signature — with from __future__ import annotations, get_type_hints eval-compiles the stringized annotations each time (2,472 builtins.compile calls in the profile), and
2. evaluated the memo body twice (once for the tag preview, once inside _create_component_definition).

Fix (behavior-preserving)

• Hoist the params analysis to an import-time constant (_PASSTHROUGH_PARAMS): the passthrough wrapper signature is always (children: Var[Component]) -> Component.
• Reuse the evaluated preview as the definition body (_LazyBody.ready(_lift_rest_props(preview))) instead of re-running the memo function.
• Check CompileContext.auto_memo_components for the computed (tag, source_module) key first (new optional existing_definitions parameter): repeated identical subtrees reuse the first definition instead of rebuilding an equivalent one per call site. The cache stays per-CompileContext, so definitions are still never shared across compiles (covered by test_passthrough_memo_definitions_are_not_shared_globally).

Compile output is unchanged: the surviving definition is structurally identical to the one that previously overwrote the registry entry last.

Measured results (CodSpeed instrumentation, this PR vs main @ 9a5c4d3)

Overall: +21.96% compile performance.

Benchmark	BASE	HEAD	Efficiency
test_compile_all_artifacts[_stateful_page]	27.2 ms	21.7 ms	+25.74%
test_compile_page[_stateful_page]	30.8 ms	25.3 ms	+21.94%
test_compile_page_full_context[_stateful_page]	35.8 ms	30.3 ms	+18.3%
test_compile_page_duplicated_rows (new)	N/A	828.1 ms	baseline for follow-ups

Verification

• New unit tests: cache-hit returns the cached definition object (and a different source_module still misses); the memo body is evaluated exactly once per definition build.
• New CodSpeed benchmark test_compile_page_duplicated_rows (200 identical stateful rows) stresses this path so follow-up compiler-perf PRs are measured on every run.

Part of a compiler-performance series; tracked in Linear as ENG-10101.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Jy8uHH11KircGa2MbTrR8g

[greptile-apps]

Greptile Summary

This PR speeds up auto-memoized passthrough component compilation. The main changes are:

• Reuses memo definitions for duplicate passthrough tags within a compile context.
• Computes passthrough tags before building the memo body.
• Caches the shared passthrough parameter and hole render helpers.
• Expands component hashes to include dynamic imports.
• Adds unit coverage and a duplicated-rows compile benchmark.

Confidence Score: 5/5

This looks safe to merge.

• No blocking issues found in the changed code.

Important Files Changed

Filename	Overview
packages/reflex-base/src/reflex_base/components/memo.py	Adds cached passthrough helpers and per-compile memo definition reuse.
reflex/compiler/plugins/memoize.py	Moves event-trigger rewriting into the memo body preparation path.
packages/reflex-base/src/reflex_base/components/component.py	Updates deterministic component hashing and includes dynamic imports.
reflex/compiler/utils.py	Compiles passthrough memo bodies using the stored hole child shape.
tests/units/compiler/test_memoize_plugin.py	Adds tests for memo definition reuse, trigger rewriting, and hash coverage.
tests/benchmarks/test_compilation.py	Adds a duplicated-rows benchmark for the memo dedup path.

_{Reviews (7): Last reviewed commit: "Update moment pyi hash: memo dedup chang..." | Re-trigger Greptile}

[codspeed-hq]

Merging this PR will improve performance by 28.47%

⚠️ Different runtime environments detected

Some benchmarks with significant performance changes were compared across different runtime environments,
which may affect the accuracy of the results.

Open the report in CodSpeed to investigate

⚡ 3 improved benchmarks
✅ 23 untouched benchmarks
🆕 1 new benchmark
⏩ 8 skipped benchmarks¹

Performance Changes

	Mode	Benchmark	BASE	HEAD	Efficiency
⚡	Simulation	test_compile_page[_stateful_page]	30.4 ms	23 ms	+31.86%
⚡	Simulation	test_compile_page_full_context[_stateful_page]	34.3 ms	27 ms	+27.36%
⚡	Simulation	test_compile_all_artifacts[_stateful_page]	26.8 ms	21.2 ms	+26.25%
🆕	Simulation	test_compile_page_duplicated_rows	N/A	645.7 ms	N/A

Tip

Curious why this is faster? Comment @codspeedbot explain why this is faster on this PR, or directly use the CodSpeed MCP with your agent.

---

_{Comparing claude/reflex-compiler-perf-t8ztc9-11-memoize-dedup (460c941) with claude/reflex-perf-optimizations-21kg8y-emit-update (24c3f7a)}

Footnotes

1. 8 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[linear-code]

ENG-10101