Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
119 changes: 70 additions & 49 deletions compiler/crates/react_compiler/src/entrypoint/program.rs
Original file line number Diff line number Diff line change
Expand Up @@ -2581,7 +2581,7 @@ fn build_compiled_expression_matching_kind(
/// Apply compiled functions back to the AST by replacing original function nodes
/// with their compiled versions, inserting outlined functions, and adding imports.
fn apply_compiled_functions(
compiled_fns: &[CompiledFnForReplacement],
compiled_fns: Vec<CompiledFnForReplacement>,
program: &mut Program,
context: &mut ProgramContext,
) {
Expand All @@ -2594,7 +2594,7 @@ fn apply_compiled_functions(

// If gating is enabled, determine which functions are referenced before declaration
let referenced_before_decl = if has_gating {
get_functions_referenced_before_declaration(program, compiled_fns)
get_functions_referenced_before_declaration(program, &compiled_fns)
} else {
FxHashSet::default()
};
Expand Down Expand Up @@ -2629,15 +2629,23 @@ fn apply_compiled_functions(
// (matching TS pushContainer behavior)
let mut outlined_decls: Vec<(Option<u32>, OriginalFnKind, FunctionDeclaration)> = Vec::new(); // (node_id, kind, decl)

// Computed before the loop below consumes `compiled_fns`.
let needs_memo_import = compiled_fns
.iter()
.any(|cf| cf.codegen_fn.memo_slots_used > 0);

// Replace each compiled function in the AST
for (idx, compiled) in compiled_fns.iter().enumerate() {
for (idx, mut compiled) in compiled_fns.into_iter().enumerate() {
let fn_node_id = compiled.fn_node_id;
let original_kind = compiled.original_kind;

// Collect outlined functions for this compiled function
for outlined in &compiled.codegen_fn.outlined {
for outlined in std::mem::take(&mut compiled.codegen_fn.outlined) {
let outlined_decl = FunctionDeclaration {
base: BaseNode::typed("FunctionDeclaration"),
id: outlined.func.id.clone(),
params: outlined.func.params.clone(),
body: outlined.func.body.clone(),
id: outlined.func.id,
params: outlined.func.params,
body: outlined.func.body,
generator: outlined.func.generator,
is_async: outlined.func.is_async,
declare: None,
Expand All @@ -2647,32 +2655,34 @@ fn apply_compiled_functions(
component_declaration: false,
hook_declaration: false,
};
outlined_decls.push((compiled.fn_node_id, compiled.original_kind, outlined_decl));
outlined_decls.push((fn_node_id, original_kind, outlined_decl));
}

if let Some(ref gating_config) = compiled.gating {
let is_ref_before_decl = compiled
.fn_node_id
.map_or(false, |nid| referenced_before_decl.contains(&nid));
let is_ref_before_decl =
fn_node_id.map_or(false, |nid| referenced_before_decl.contains(&nid));

if is_ref_before_decl && compiled.original_kind == OriginalFnKind::FunctionDeclaration {
if is_ref_before_decl && original_kind == OriginalFnKind::FunctionDeclaration {
// Use the hoisted function declaration gating pattern
apply_gated_function_hoisted(program, compiled, gating_config, context);
apply_gated_function_hoisted(program, &compiled, gating_config, context);
} else {
// Use the conditional expression gating pattern
let original_expr = original_expressions[idx].clone();
apply_gated_function_conditional(
program,
compiled,
&compiled,
gating_config,
original_expr,
context,
);
}
} else {
// No gating: replace the function directly (original behavior)
if let Some(node_id) = compiled.fn_node_id {
let mut visitor = ReplaceFnVisitor { node_id, compiled };
if let Some(node_id) = fn_node_id {
let mut visitor = ReplaceFnVisitor {
node_id,
compiled: Some(compiled.codegen_fn),
};
walk_program_mut(&mut visitor, program);
}
}
Expand Down Expand Up @@ -2704,9 +2714,6 @@ fn apply_compiled_functions(
}

// Register the memo cache import and rename useMemoCache references.
let needs_memo_import = compiled_fns
.iter()
.any(|cf| cf.codegen_fn.memo_slots_used > 0);
if needs_memo_import {
let import_spec = context.add_memo_cache_import();
let local_name = import_spec.name;
Expand Down Expand Up @@ -3613,20 +3620,32 @@ fn expr_has_fn_with_node_id(expr: &Expression, node_id: u32) -> bool {
}

/// Visitor that replaces a compiled function in the AST by matching `base.node_id`.
struct ReplaceFnVisitor<'a> {
struct ReplaceFnVisitor {
node_id: u32,
compiled: &'a CompiledFnForReplacement,
/// Owned so the compiled body can be moved into the AST rather than deep
/// cloned. Exactly one arm below fires, because each returns `Stop` once it
/// matches `node_id`.
compiled: Option<CodegenFunction>,
}

impl ReplaceFnVisitor {
fn take(&mut self) -> CodegenFunction {
self.compiled
.take()
.expect("ReplaceFnVisitor matched more than once; node ids must be unique")
}
}

impl MutVisitor for ReplaceFnVisitor<'_> {
impl MutVisitor for ReplaceFnVisitor {
fn visit_statement(&mut self, stmt: &mut Statement) -> VisitResult {
match stmt {
Statement::FunctionDeclaration(f) if f.base.node_id == Some(self.node_id) => {
f.id = self.compiled.codegen_fn.id.clone();
f.params = self.compiled.codegen_fn.params.clone();
f.body = self.compiled.codegen_fn.body.clone();
f.generator = self.compiled.codegen_fn.generator;
f.is_async = self.compiled.codegen_fn.is_async;
let compiled = self.take();
f.id = compiled.id;
f.params = compiled.params;
f.body = compiled.body;
f.generator = compiled.generator;
f.is_async = compiled.is_async;
f.return_type = None;
f.type_parameters = None;
f.predicate = None;
Expand All @@ -3636,11 +3655,12 @@ impl MutVisitor for ReplaceFnVisitor<'_> {
Statement::ExportDefaultDeclaration(export) => {
if let ExportDefaultDecl::FunctionDeclaration(f) = export.declaration.as_mut() {
if f.base.node_id == Some(self.node_id) {
f.id = self.compiled.codegen_fn.id.clone();
f.params = self.compiled.codegen_fn.params.clone();
f.body = self.compiled.codegen_fn.body.clone();
f.generator = self.compiled.codegen_fn.generator;
f.is_async = self.compiled.codegen_fn.is_async;
let compiled = self.take();
f.id = compiled.id;
f.params = compiled.params;
f.body = compiled.body;
f.generator = compiled.generator;
f.is_async = compiled.is_async;
f.return_type = None;
f.type_parameters = None;
f.predicate = None;
Expand All @@ -3653,11 +3673,12 @@ impl MutVisitor for ReplaceFnVisitor<'_> {
if let Some(ref mut decl) = export.declaration {
if let Declaration::FunctionDeclaration(f) = decl.as_mut() {
if f.base.node_id == Some(self.node_id) {
f.id = self.compiled.codegen_fn.id.clone();
f.params = self.compiled.codegen_fn.params.clone();
f.body = self.compiled.codegen_fn.body.clone();
f.generator = self.compiled.codegen_fn.generator;
f.is_async = self.compiled.codegen_fn.is_async;
let compiled = self.take();
f.id = compiled.id;
f.params = compiled.params;
f.body = compiled.body;
f.generator = compiled.generator;
f.is_async = compiled.is_async;
f.return_type = None;
f.type_parameters = None;
f.predicate = None;
Expand All @@ -3675,22 +3696,22 @@ impl MutVisitor for ReplaceFnVisitor<'_> {
fn visit_expression(&mut self, expr: &mut Expression) -> VisitResult {
match expr {
Expression::FunctionExpression(f) if f.base.node_id == Some(self.node_id) => {
f.id = self.compiled.codegen_fn.id.clone();
f.params = self.compiled.codegen_fn.params.clone();
f.body = self.compiled.codegen_fn.body.clone();
f.generator = self.compiled.codegen_fn.generator;
f.is_async = self.compiled.codegen_fn.is_async;
let compiled = self.take();
f.id = compiled.id;
f.params = compiled.params;
f.body = compiled.body;
f.generator = compiled.generator;
f.is_async = compiled.is_async;
f.return_type = None;
f.type_parameters = None;
VisitResult::Stop
}
Expression::ArrowFunctionExpression(f) if f.base.node_id == Some(self.node_id) => {
f.params = self.compiled.codegen_fn.params.clone();
f.body = Box::new(ArrowFunctionBody::BlockStatement(
self.compiled.codegen_fn.body.clone(),
));
f.generator = self.compiled.codegen_fn.generator;
f.is_async = self.compiled.codegen_fn.is_async;
let compiled = self.take();
f.params = compiled.params;
f.body = Box::new(ArrowFunctionBody::BlockStatement(compiled.body));
f.generator = compiled.generator;
f.is_async = compiled.is_async;
f.expression = Some(false);
f.return_type = None;
f.type_parameters = None;
Expand Down Expand Up @@ -4018,7 +4039,7 @@ pub fn compile_program(mut file: File, scope: ScopeInfo, options: PluginOptions)
}

// Now we can mutate file.program
apply_compiled_functions(&replacements, &mut file.program, &mut context);
apply_compiled_functions(replacements, &mut file.program, &mut context);

let timing_entries = context.timing.into_entries();

Expand Down
Loading
Loading