Skip to content
Closed
3 changes: 3 additions & 0 deletions .claude/skills/sync-react-compiler.md
Original file line number Diff line number Diff line change
Expand Up @@ -69,6 +69,9 @@ the porting reference for the AST-boundary files.
cargo check -p bun_react_compiler
bun bd test test/bundler/transpiler/react-compiler.test.ts
```
`grep -rn "Intentional deviation" src/react_compiler` lists the places where
the port differs from upstream on purpose. Keep each one unless upstream
now fixes what its comment names.
Snapshots will change if codegen changed upstream — review the diff against
upstream's new fixture output and update with `bun bd test -u` if it
matches.
Expand Down
250 changes: 177 additions & 73 deletions src/react_compiler/lowering/build_hir/expr.rs
Original file line number Diff line number Diff line change
Expand Up @@ -372,7 +372,7 @@ fn lower_binary(
let loc = convert_loc(bun_loc);

match bin.op {
BinComma => lower_sequence(builder, bin, loc),
BinComma => lower_sequence(builder, bin, loc, true),
BinLogicalOr | BinLogicalAnd | BinNullishCoalescing => lower_logical(builder, bin, loc),
BinAssign => lower_simple_assignment(builder, bin, loc),
BinAddAssign | BinSubAssign | BinMulAssign | BinDivAssign | BinRemAssign | BinPowAssign
Expand Down Expand Up @@ -607,23 +607,40 @@ fn lower_sequence(
builder: &mut HirBuilder,
bin: &E::Binary,
loc: Option<SourceLocation>,
value_is_used: bool,
) -> Result<InstructionValue, CompilerError> {
let continuation_block = builder.reserve(builder.current_block_kind());
let continuation_id = continuation_block.id;
let place = build_temporary_place(builder, loc);

let sequence_block = builder.try_enter(BlockKind::Sequence, |builder, _block_id| {
lower_in_sequence_block(builder, loc, |builder| {
fn flatten_comma(builder: &mut HirBuilder, e: &Expr) -> Result<Place, CompilerError> {
if let Data::EBinary(b) = &e.data {
if b.op == OpCode::BinComma {
flatten_comma(builder, &b.left)?;
return flatten_comma(builder, &b.right);
}
}
lower_expression_to_temporary(builder, e)
lower_expression_for_effect(builder, e)
}
flatten_comma(builder, &bin.left)?;
let last = lower_expression_to_temporary(builder, &bin.right)?;
if value_is_used {
lower_expression_to_temporary(builder, &bin.right)
} else {
flatten_comma(builder, &bin.right)
}
})
}

/// Runs `lower` in a new sequence block. The place it returns is the value of
/// the sequence.
Comment thread
robobun marked this conversation as resolved.
Resolved
fn lower_in_sequence_block(
builder: &mut HirBuilder,
loc: Option<SourceLocation>,
lower: impl FnOnce(&mut HirBuilder) -> Result<Place, CompilerError>,
) -> Result<InstructionValue, CompilerError> {
let continuation_block = builder.reserve(builder.current_block_kind());
let continuation_id = continuation_block.id;
let place = build_temporary_place(builder, loc);

let sequence_block = builder.try_enter(BlockKind::Sequence, |builder, _block_id| {
let last = lower(builder)?;
lower_value_to_temporary(
builder,
InstructionValue::StoreLocal {
Expand Down Expand Up @@ -927,32 +944,41 @@ fn lower_compound_assignment_identifier(
effect: Effect::Unknown,
loc: ident_loc,
};
if builder.is_context_identifier(ref_) {
lower_value_to_temporary(
builder,
InstructionValue::StoreContext {
lvalue: LValue {
kind: InstructionKind::Reassign,
place: place.clone(),
},
value: binary_place,
loc,
let is_context = builder.is_context_identifier(ref_);
let store = if is_context {
InstructionValue::StoreContext {
lvalue: LValue {
kind: InstructionKind::Reassign,
place: place.clone(),
},
)?;
Ok(InstructionValue::LoadContext { place, loc })
value: binary_place,
loc,
}
} else {
lower_value_to_temporary(
builder,
InstructionValue::StoreLocal {
lvalue: LValue {
kind: InstructionKind::Reassign,
place: place.clone(),
},
value: binary_place,
type_annotation: None,
loc,
InstructionValue::StoreLocal {
lvalue: LValue {
kind: InstructionKind::Reassign,
place: place.clone(),
},
)?;
value: binary_place,
type_annotation: None,
loc,
}
};
let temp = lower_value_to_temporary(builder, store)?;
// Intentional deviation: upstream drops the temporary of the store
// and returns a load of `x`. The store is then a statement, and in
// a nested function no pass names the operands that come before
// it: `[x, x += 1]` gave `[1, 1]`. The value of the store keeps the
// assignment in place, as for `x = y`.
Comment thread
robobun marked this conversation as resolved.
Resolved
if builder.is_nested_function() {
Ok(InstructionValue::LoadLocal {
loc: temp.loc,
place: temp,
})
} else if is_context {
Ok(InstructionValue::LoadContext { place, loc })
} else {
Ok(InstructionValue::LoadLocal { place, loc })
}
}
Expand Down Expand Up @@ -1023,7 +1049,7 @@ fn lower_unary(
Ok(unsupported_node("UnaryExpression", loc))
}
},
UnPreInc | UnPreDec | UnPostInc | UnPostDec => lower_update(builder, unary, loc),
UnPreInc | UnPreDec | UnPostInc | UnPostDec => lower_update(builder, unary, loc, true),
_ => {
let Some(operator) = super::helpers::convert_unary_operator(unary.op) else {
return Err(todo_err("EUnary op", loc));
Expand All @@ -1039,10 +1065,32 @@ fn lower_unary(
}
}

/// Intentional deviation: upstream has no such entry point. Lowers an expression
/// whose value nothing reads: an expression statement, the update of a `for`, or
/// an operand of a comma that is not the last one (`minify.syntax` joins
/// `o.p++; o.q++;` into `o.p++, o.q++;`). `lower_update` needs to know.
Comment thread
robobun marked this conversation as resolved.
Resolved
pub(super) fn lower_expression_for_effect(
builder: &mut HirBuilder,
expr: &Expr,
) -> Result<Place, CompilerError> {
let loc = convert_loc(expr.loc);
let value = match &expr.data {
Data::EUnary(unary) if matches!(unary.op, OpCode::UnPostInc | OpCode::UnPostDec) => {
lower_update(builder, unary, loc, false)?
}
Data::EBinary(bin) if bin.op == OpCode::BinComma => {
lower_sequence(builder, bin, loc, false)?
}
_ => lower_expression(builder, expr)?,
};
lower_value_to_temporary(builder, value)
}

fn lower_update(
builder: &mut HirBuilder,
unary: &E::Unary,
loc: Option<SourceLocation>,
value_is_used: bool,
) -> Result<InstructionValue, CompilerError> {
let prefix = matches!(unary.op, OpCode::UnPreInc | OpCode::UnPreDec);
let operation = match unary.op {
Expand All @@ -1057,49 +1105,36 @@ fn lower_update(
UpdateOperator::Decrement => BinaryOperator::Subtract,
};
let member_loc = convert_loc(unary.value.loc);
let lowered = lower_member_expression(builder, &unary.value, None)?;
let object = lowered.object;
let lowered_property = lowered.property;
let prev_value = lower_value_to_temporary(builder, lowered.value)?;

let one = lower_value_to_temporary(
builder,
InstructionValue::Primitive {
value: PrimitiveValue::Number(FloatValue::new(1.0)),
loc: None,
},
)?;
let updated = lower_value_to_temporary(
builder,
InstructionValue::BinaryExpression {
operator: binary_op,
left: prev_value.clone(),
right: one,
loc: member_loc,
},
)?;

let new_value_place = match lowered_property {
MemberProperty::Literal(prop_literal) => lower_value_to_temporary(
builder,
InstructionValue::PropertyStore {
object,
property: prop_literal,
value: updated,
loc: member_loc,
},
)?,
MemberProperty::Computed(prop_place) => lower_value_to_temporary(
builder,
InstructionValue::ComputedStore {
object,
property: prop_place,
value: updated,
loc: member_loc,
},
)?,
};
// Intentional deviation: upstream returns the temporary that holds
// the load of `o.p`. In a nested function no pass names it, so
// codegen prints `o.p` again after the store: `const id = o.p++`
// gets the new value (facebook/react#35205).
// `(o.p = (old = o.p) + 1, old)` keeps the update in place among the
// other operands. Remove this when upstream fixes nested functions
// (facebook/react#36737 covers the outlined ones only).
Comment thread
robobun marked this conversation as resolved.
Resolved
if !prefix && value_is_used && builder.is_nested_function() {
let old_value = builder.declare_temporary_at_entry(member_loc);
return lower_in_sequence_block(builder, loc, |builder| {
lower_member_update(
builder,
&unary.value,
binary_op,
member_loc,
Some(&old_value),
)?;
lower_value_to_temporary(
builder,
InstructionValue::LoadLocal {
place: old_value.clone(),
loc: member_loc,
},
)
});
}

let (prev_value, new_value_place) =
lower_member_update(builder, &unary.value, binary_op, member_loc, None)?;
let result_place = if prefix { new_value_place } else { prev_value };
Ok(InstructionValue::LoadLocal {
loc: result_place.loc,
Expand All @@ -1125,6 +1160,75 @@ fn lower_update(
}
}

/// Lowers `o.p = o.p + 1` (or `- 1`) and returns the value loaded and the
/// value stored. With `old_value`, the sum reads the value loaded through an
/// assignment to that local: `o.p = (old = o.p) + 1`.
Comment thread
robobun marked this conversation as resolved.
Resolved
fn lower_member_update(
builder: &mut HirBuilder,
member: &Expr,
binary_op: BinaryOperator,
member_loc: Option<SourceLocation>,
old_value: Option<&Place>,
) -> Result<(Place, Place), CompilerError> {
let lowered = lower_member_expression(builder, member, None)?;
let object = lowered.object;
let lowered_property = lowered.property;
let mut prev_value = lower_value_to_temporary(builder, lowered.value)?;
if let Some(old_value) = old_value {
prev_value = lower_value_to_temporary(
builder,
InstructionValue::StoreLocal {
lvalue: LValue {
kind: InstructionKind::Reassign,
place: old_value.clone(),
},
value: prev_value,
type_annotation: None,
loc: member_loc,
},
)?;
}

let one = lower_value_to_temporary(
builder,
InstructionValue::Primitive {
value: PrimitiveValue::Number(FloatValue::new(1.0)),
loc: None,
},
)?;
let updated = lower_value_to_temporary(
builder,
InstructionValue::BinaryExpression {
operator: binary_op,
left: prev_value.clone(),
right: one,
loc: member_loc,
},
)?;

let new_value_place = match lowered_property {
MemberProperty::Literal(prop_literal) => lower_value_to_temporary(
builder,
InstructionValue::PropertyStore {
object,
property: prop_literal,
value: updated,
loc: member_loc,
},
)?,
MemberProperty::Computed(prop_place) => lower_value_to_temporary(
builder,
InstructionValue::ComputedStore {
object,
property: prop_place,
value: updated,
loc: member_loc,
},
)?,
};
Ok((prev_value, new_value_place))
}

fn lower_update_identifier(
builder: &mut HirBuilder,
ref_: Ref,
Expand Down
1 change: 1 addition & 0 deletions src/react_compiler/lowering/build_hir/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -144,6 +144,7 @@ pub(super) fn lower_inner<'h>(
Some(context_map.clone()),
None,
parent_used_refs,
!is_top_level,
);
builder.set_import_bindings(import_bindings.clone());

Expand Down
6 changes: 3 additions & 3 deletions src/react_compiler/lowering/build_hir/stmt.rs
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,7 @@ use smallvec::SmallVec;

use crate::lowering::hir_builder::{HirBuilder, convert_loc};

use super::expr::lower_reorderable_expression;
use super::expr::{lower_expression_for_effect, lower_reorderable_expression};
use super::function::lower_function_declaration;
use super::helpers::{
AssignmentStyle, IdentifierForAssignment, build_temporary_place, lower_assignment,
Expand Down Expand Up @@ -510,7 +510,7 @@ fn lower_statement(
lower_value_to_temporary(builder, value)?;
}
Data::SExpr(expr_stmt) => {
lower_expression_to_temporary(builder, &expr_stmt.value)?;
lower_expression_for_effect(builder, &expr_stmt.value)?;
}
Data::SReturn(ret) => {
let loc = convert_loc(stmt_loc);
Expand Down Expand Up @@ -816,7 +816,7 @@ fn lower_statement(
let update_block_id = if let Some(update) = &for_stmt.update {
let update_loc = convert_loc(update.loc);
Some(builder.try_enter(BlockKind::Loop, |builder, _block_id| {
lower_expression_to_temporary(builder, update)?;
lower_expression_for_effect(builder, update)?;
Ok(Terminal::Goto {
block: test_block_id,
variant: GotoVariant::Break,
Expand Down
Loading
Loading