compare with TypeScript compiler

Author: Brooooooklyn

crates/oxc_angular_compiler/src/ir/enums.rs

@@ -246,6 +246,10 @@ pub enum ExpressionKind {
     DerivedLiteralArray,
     /// Derived literal map for pure function bodies.
     DerivedLiteralMap,
+    /// Literal array with IR expression elements.
+    LiteralArray,
+    /// Literal map (object) with IR expression values.
+    LiteralMap,
 }
 
 /// Flags for semantic variables.

crates/oxc_angular_compiler/src/ir/expression.rs

@@ -156,6 +156,12 @@ pub enum IrExpression<'a> {
     /// Derived literal map for pure function bodies.
     /// Contains IrExpression values that can include PureFunctionParameter references.
     DerivedLiteralMap(Box<'a, DerivedLiteralMapExpr<'a>>),
+    /// Literal array with IR expression elements.
+    /// Used to preserve pipe bindings inside array literals during ingest.
+    LiteralArray(Box<'a, IrLiteralArrayExpr<'a>>),
+    /// Literal map (object) with IR expression values.
+    /// Used to preserve pipe bindings inside object literals during ingest.
+    LiteralMap(Box<'a, IrLiteralMapExpr<'a>>),
 }
 
 impl<'a> IrExpression<'a> {
@@ -212,6 +218,10 @@ impl<'a> IrExpression<'a> {
             IrExpression::DerivedLiteralArray(_) => ExpressionKind::DerivedLiteralArray,
             // DerivedLiteralMap is a literal map for pure function bodies
             IrExpression::DerivedLiteralMap(_) => ExpressionKind::DerivedLiteralMap,
+            // LiteralArray is an array literal with IR expression elements
+            IrExpression::LiteralArray(_) => ExpressionKind::LiteralArray,
+            // LiteralMap is an object literal with IR expression values
+            IrExpression::LiteralMap(_) => ExpressionKind::LiteralMap,
         }
     }
 }
@@ -618,6 +628,34 @@ impl<'a> IrExpression<'a> {
                     allocator,
                 ))
             }
+            IrExpression::LiteralArray(e) => {
+                let mut elements = Vec::with_capacity_in(e.elements.len(), allocator);
+                for elem in e.elements.iter() {
+                    elements.push(elem.clone_in(allocator));
+                }
+                IrExpression::LiteralArray(Box::new_in(
+                    IrLiteralArrayExpr { elements, source_span: e.source_span },
+                    allocator,
+                ))
+            }
+            IrExpression::LiteralMap(e) => {
+                let mut keys = Vec::with_capacity_in(e.keys.len(), allocator);
+                for key in e.keys.iter() {
+                    keys.push(key.clone());
+                }
+                let mut values = Vec::with_capacity_in(e.values.len(), allocator);
+                for value in e.values.iter() {
+                    values.push(value.clone_in(allocator));
+                }
+                let mut quoted = Vec::with_capacity_in(e.quoted.len(), allocator);
+                for q in e.quoted.iter() {
+                    quoted.push(*q);
+                }
+                IrExpression::LiteralMap(Box::new_in(
+                    IrLiteralMapExpr { keys, values, quoted, source_span: e.source_span },
+                    allocator,
+                ))
+            }
         }
     }
 }
@@ -829,6 +867,30 @@ pub struct DerivedLiteralMapExpr<'a> {
     pub source_span: Option<Span>,
 }
 
+/// Literal array with IR expression elements.
+/// Used during ingest to preserve pipe bindings inside array literals.
+#[derive(Debug)]
+pub struct IrLiteralArrayExpr<'a> {
+    /// Array elements as IR expressions.
+    pub elements: Vec<'a, IrExpression<'a>>,
+    /// Source span.
+    pub source_span: Option<Span>,
+}
+
+/// Literal map (object) with IR expression values.
+/// Used during ingest to preserve pipe bindings inside object literals.
+#[derive(Debug)]
+pub struct IrLiteralMapExpr<'a> {
+    /// Map keys (string keys from the original literal map).
+    pub keys: Vec<'a, Atom<'a>>,
+    /// Map values as IR expressions.
+    pub values: Vec<'a, IrExpression<'a>>,
+    /// Whether each key is quoted.
+    pub quoted: Vec<'a, bool>,
+    /// Source span.
+    pub source_span: Option<Span>,
+}
+
 /// Pure function expression (memoized computation).
 #[derive(Debug)]
 pub struct PureFunctionExpr<'a> {
@@ -1114,17 +1176,66 @@ pub struct TernaryExpr<'a> {
 
 /// Binary operators for IR expressions.
 ///
-/// These are used for computed expressions in @for loops.
+/// These are used for computed expressions in @for loops and for preserving
+/// pipes nested in binary expressions like `a ?? (b | pipe)`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum IrBinaryOperator {
-    /// Strict equality (===)
-    Identical,
-    /// Strict inequality (!==)
-    NotIdentical,
+    /// Addition (+)
+    Plus,
     /// Subtraction (-)
     Minus,
+    /// Multiplication (*)
+    Multiply,
+    /// Division (/)
+    Divide,
     /// Modulo (%)
     Modulo,
+    /// Exponentiation (**)
+    Exponentiation,
+    /// Loose equality (==)
+    Equals,
+    /// Loose inequality (!=)
+    NotEquals,
+    /// Strict equality (===)
+    Identical,
+    /// Strict inequality (!==)
+    NotIdentical,
+    /// Less than (<)
+    Lower,
+    /// Less than or equal (<=)
+    LowerEquals,
+    /// Greater than (>)
+    Bigger,
+    /// Greater than or equal (>=)
+    BiggerEquals,
+    /// Logical and (&&)
+    And,
+    /// Logical or (||)
+    Or,
+    /// Nullish coalescing (??)
+    NullishCoalesce,
+    /// In operator (in)
+    In,
+    /// Assignment (=)
+    Assign,
+    /// Addition assignment (+=)
+    AdditionAssignment,
+    /// Subtraction assignment (-=)
+    SubtractionAssignment,
+    /// Multiplication assignment (*=)
+    MultiplicationAssignment,
+    /// Division assignment (/=)
+    DivisionAssignment,
+    /// Remainder assignment (%=)
+    RemainderAssignment,
+    /// Exponentiation assignment (**=)
+    ExponentiationAssignment,
+    /// And assignment (&&=)
+    AndAssignment,
+    /// Or assignment (||=)
+    OrAssignment,
+    /// Nullish coalescing assignment (??=)
+    NullishCoalesceAssignment,
 }
 
 // ============================================================================
@@ -1246,6 +1357,16 @@ pub fn transform_expressions_in_expression<'a, F>(
                 transform_expressions_in_expression(value, transform, flags);
             }
         }
+        IrExpression::LiteralArray(e) => {
+            for elem in e.elements.iter_mut() {
+                transform_expressions_in_expression(elem, transform, flags);
+            }
+        }
+        IrExpression::LiteralMap(e) => {
+            for value in e.values.iter_mut() {
+                transform_expressions_in_expression(value, transform, flags);
+            }
+        }
         IrExpression::Ternary(e) => {
             transform_expressions_in_expression(&mut e.condition, transform, flags);
             transform_expressions_in_expression(&mut e.true_expr, transform, flags);
@@ -1389,6 +1510,16 @@ pub fn visit_expressions_in_expression<'a, F>(
                 visit_expressions_in_expression(value, visitor, flags);
             }
         }
+        IrExpression::LiteralArray(e) => {
+            for elem in e.elements.iter() {
+                visit_expressions_in_expression(elem, visitor, flags);
+            }
+        }
+        IrExpression::LiteralMap(e) => {
+            for value in e.values.iter() {
+                visit_expressions_in_expression(value, visitor, flags);
+            }
+        }
         IrExpression::Ternary(e) => {
             visit_expressions_in_expression(&e.condition, visitor, flags);
             visit_expressions_in_expression(&e.true_expr, visitor, flags);
@@ -1497,19 +1628,169 @@ pub fn transform_expressions_in_update_op<'a, F>(
         UpdateOp::DeferWhen(op) => {
             transform_expressions_in_expression(&mut op.condition, transform, flags);
         }
+        UpdateOp::Statement(op) => {
+            // Statement ops may contain WrappedIrNode which wraps IR expressions.
+            // We need to transform these expressions so that phases like naming
+            // can propagate variable names to ReadVariableExpr inside.
+            transform_expressions_in_output_statement(&mut op.statement, transform, flags);
+        }
         // Operations without expressions
         UpdateOp::ListEnd(_)
         | UpdateOp::Advance(_)
         | UpdateOp::I18nApply(_)
-        | UpdateOp::Animation(_)
-        | UpdateOp::Statement(_) => {
-            // Statement ops contain OutputStatement with WrappedNodeExpr which
-            // wraps IR expressions. These are handled during the reify phase,
-            // not during the expression transformation phase.
+        | UpdateOp::Animation(_) => {}
+    }
+}
+
+/// Transform expressions inside an OutputStatement.
+/// This handles WrappedIrNode expressions that contain IR expressions.
+fn transform_expressions_in_output_statement<'a, F>(
+    stmt: &mut crate::output::ast::OutputStatement<'a>,
+    transform: &F,
+    flags: VisitorContextFlag,
+) where
+    F: Fn(&mut IrExpression<'a>, VisitorContextFlag),
+{
+    use crate::output::ast::OutputStatement;
+
+    match stmt {
+        OutputStatement::Expression(expr_stmt) => {
+            transform_expressions_in_output_expression(&mut expr_stmt.expr, transform, flags);
+        }
+        OutputStatement::Return(ret_stmt) => {
+            transform_expressions_in_output_expression(&mut ret_stmt.value, transform, flags);
+        }
+        OutputStatement::DeclareVar(decl) => {
+            if let Some(ref mut value) = decl.value {
+                transform_expressions_in_output_expression(value, transform, flags);
+            }
+        }
+        OutputStatement::If(if_stmt) => {
+            transform_expressions_in_output_expression(&mut if_stmt.condition, transform, flags);
+            for stmt in if_stmt.true_case.iter_mut() {
+                transform_expressions_in_output_statement(stmt, transform, flags);
+            }
+            for stmt in if_stmt.false_case.iter_mut() {
+                transform_expressions_in_output_statement(stmt, transform, flags);
+            }
+        }
+        OutputStatement::DeclareFunction(_) => {
+            // Function declarations don't contain IrExpressions to transform
         }
     }
 }
 
+/// Transform expressions inside an OutputExpression.
+/// This handles WrappedIrNode which contains IR expressions.
+fn transform_expressions_in_output_expression<'a, F>(
+    expr: &mut crate::output::ast::OutputExpression<'a>,
+    transform: &F,
+    flags: VisitorContextFlag,
+) where
+    F: Fn(&mut IrExpression<'a>, VisitorContextFlag),
+{
+    use crate::output::ast::OutputExpression;
+
+    match expr {
+        OutputExpression::WrappedIrNode(wrapped) => {
+            transform_expressions_in_expression(&mut wrapped.node, transform, flags);
+        }
+        OutputExpression::Conditional(cond) => {
+            transform_expressions_in_output_expression(&mut cond.condition, transform, flags);
+            transform_expressions_in_output_expression(&mut cond.true_case, transform, flags);
+            if let Some(false_case) = &mut cond.false_case {
+                transform_expressions_in_output_expression(false_case, transform, flags);
+            }
+        }
+        OutputExpression::BinaryOperator(bin) => {
+            transform_expressions_in_output_expression(&mut bin.lhs, transform, flags);
+            transform_expressions_in_output_expression(&mut bin.rhs, transform, flags);
+        }
+        OutputExpression::UnaryOperator(un) => {
+            transform_expressions_in_output_expression(&mut un.expr, transform, flags);
+        }
+        OutputExpression::Not(not) => {
+            transform_expressions_in_output_expression(&mut not.condition, transform, flags);
+        }
+        OutputExpression::ReadProp(member) => {
+            transform_expressions_in_output_expression(&mut member.receiver, transform, flags);
+        }
+        OutputExpression::ReadKey(idx) => {
+            transform_expressions_in_output_expression(&mut idx.receiver, transform, flags);
+            transform_expressions_in_output_expression(&mut idx.index, transform, flags);
+        }
+        OutputExpression::TaggedTemplateLiteral(tagged) => {
+            transform_expressions_in_output_expression(&mut tagged.tag, transform, flags);
+            for expr in tagged.template.expressions.iter_mut() {
+                transform_expressions_in_output_expression(expr, transform, flags);
+            }
+        }
+        OutputExpression::ArrowFunction(arrow) => match &mut arrow.body {
+            crate::output::ast::ArrowFunctionBody::Expression(expr) => {
+                transform_expressions_in_output_expression(expr, transform, flags);
+            }
+            crate::output::ast::ArrowFunctionBody::Statements(stmts) => {
+                for stmt in stmts.iter_mut() {
+                    transform_expressions_in_output_statement(stmt, transform, flags);
+                }
+            }
+        },
+        OutputExpression::LiteralArray(arr) => {
+            for elem in arr.entries.iter_mut() {
+                transform_expressions_in_output_expression(elem, transform, flags);
+            }
+        }
+        OutputExpression::LiteralMap(obj) => {
+            for entry in obj.entries.iter_mut() {
+                transform_expressions_in_output_expression(&mut entry.value, transform, flags);
+                if entry.quoted {
+                    // Key is always a string, no sub-expressions
+                }
+            }
+        }
+        OutputExpression::InvokeFunction(inv) => {
+            transform_expressions_in_output_expression(&mut inv.fn_expr, transform, flags);
+            for arg in inv.args.iter_mut() {
+                transform_expressions_in_output_expression(arg, transform, flags);
+            }
+        }
+        OutputExpression::Function(func) => {
+            for stmt in func.statements.iter_mut() {
+                transform_expressions_in_output_statement(stmt, transform, flags);
+            }
+        }
+        OutputExpression::Instantiate(inst) => {
+            transform_expressions_in_output_expression(&mut inst.class_expr, transform, flags);
+            for arg in inst.args.iter_mut() {
+                transform_expressions_in_output_expression(arg, transform, flags);
+            }
+        }
+        OutputExpression::Parenthesized(paren) => {
+            transform_expressions_in_output_expression(&mut paren.expr, transform, flags);
+        }
+        OutputExpression::Comma(comma) => {
+            for part in comma.parts.iter_mut() {
+                transform_expressions_in_output_expression(part, transform, flags);
+            }
+        }
+        OutputExpression::Typeof(typeof_expr) => {
+            transform_expressions_in_output_expression(&mut typeof_expr.expr, transform, flags);
+        }
+        OutputExpression::Void(void_expr) => {
+            transform_expressions_in_output_expression(&mut void_expr.expr, transform, flags);
+        }
+        // Leaf expressions without sub-expressions
+        OutputExpression::Literal(_)
+        | OutputExpression::TemplateLiteral(_)
+        | OutputExpression::RegularExpressionLiteral(_)
+        | OutputExpression::ReadVar(_)
+        | OutputExpression::External(_)
+        | OutputExpression::LocalizedString(_)
+        | OutputExpression::WrappedNode(_)
+        | OutputExpression::DynamicImport(_) => {}
+    }
+}
+
 /// Transform all expressions in a create operation.
 pub fn transform_expressions_in_create_op<'a, F>(
     op: &mut CreateOp<'a>,
@@ -2208,6 +2489,14 @@ pub fn vars_used_by_ir_expression(expr: &IrExpression<'_>) -> u32 {
             map.values.iter().map(vars_used_by_ir_expression).sum()
         }
 
+        // LiteralArray: sum of vars used by all elements
+        IrExpression::LiteralArray(arr) => {
+            arr.elements.iter().map(vars_used_by_ir_expression).sum()
+        }
+
+        // LiteralMap: sum of vars used by all values
+        IrExpression::LiteralMap(map) => map.values.iter().map(vars_used_by_ir_expression).sum(),
+
         // Ternary: sum of vars used by all branches
         IrExpression::Ternary(ternary) => {
             vars_used_by_ir_expression(&ternary.condition)