more alignment

Author: Brooooooklyn

crates/oxc_angular_compiler/src/ir/enums.rs

@@ -250,17 +250,30 @@ pub enum ExpressionKind {
     LiteralArray,
     /// Literal map (object) with IR expression values.
     LiteralMap,
+    /// Logical NOT expression (!expr).
+    Not,
+    /// Unary operator expression (+expr or -expr).
+    Unary,
+    /// Typeof expression (typeof expr).
+    Typeof,
+    /// Void expression (void expr).
+    Void,
 }
 
 /// Flags for semantic variables.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub struct VariableFlags(u8);
 
 impl VariableFlags {
     /// No flags.
     pub const NONE: Self = Self(0b0000);
     /// Always inline this variable.
     pub const ALWAYS_INLINE: Self = Self(0b0001);
+
+    /// Check if a flag is set.
+    pub fn contains(self, other: Self) -> bool {
+        (self.0 & other.0) == other.0
+    }
 }
 
 /// Kinds of semantic variables.

crates/oxc_angular_compiler/src/ir/expression.rs

@@ -162,6 +162,18 @@ pub enum IrExpression<'a> {
     /// Literal map (object) with IR expression values.
     /// Used to preserve pipe bindings inside object literals during ingest.
     LiteralMap(Box<'a, IrLiteralMapExpr<'a>>),
+    /// Logical NOT expression (!expr).
+    /// Used to preserve pipe bindings inside negation expressions during ingest.
+    Not(Box<'a, NotExpr<'a>>),
+    /// Unary operator expression (+expr or -expr).
+    /// Used to preserve pipe bindings inside unary expressions during ingest.
+    Unary(Box<'a, UnaryExpr<'a>>),
+    /// Typeof expression (typeof expr).
+    /// Used to preserve pipe bindings inside typeof expressions during ingest.
+    Typeof(Box<'a, TypeofExpr<'a>>),
+    /// Void expression (void expr).
+    /// Used to preserve pipe bindings inside void expressions during ingest.
+    Void(Box<'a, VoidExpr<'a>>),
 }
 
 impl<'a> IrExpression<'a> {
@@ -222,6 +234,14 @@ impl<'a> IrExpression<'a> {
             IrExpression::LiteralArray(_) => ExpressionKind::LiteralArray,
             // LiteralMap is an object literal with IR expression values
             IrExpression::LiteralMap(_) => ExpressionKind::LiteralMap,
+            // Not is a logical NOT expression
+            IrExpression::Not(_) => ExpressionKind::Not,
+            // Unary is a unary operator expression (+/-)
+            IrExpression::Unary(_) => ExpressionKind::Unary,
+            // Typeof is a typeof expression
+            IrExpression::Typeof(_) => ExpressionKind::Typeof,
+            // Void is a void expression
+            IrExpression::Void(_) => ExpressionKind::Void,
         }
     }
 }
@@ -656,6 +676,35 @@ impl<'a> IrExpression<'a> {
                     allocator,
                 ))
             }
+            IrExpression::Not(e) => IrExpression::Not(Box::new_in(
+                NotExpr {
+                    expr: Box::new_in(e.expr.clone_in(allocator), allocator),
+                    source_span: e.source_span,
+                },
+                allocator,
+            )),
+            IrExpression::Unary(e) => IrExpression::Unary(Box::new_in(
+                UnaryExpr {
+                    operator: e.operator,
+                    expr: Box::new_in(e.expr.clone_in(allocator), allocator),
+                    source_span: e.source_span,
+                },
+                allocator,
+            )),
+            IrExpression::Typeof(e) => IrExpression::Typeof(Box::new_in(
+                TypeofExpr {
+                    expr: Box::new_in(e.expr.clone_in(allocator), allocator),
+                    source_span: e.source_span,
+                },
+                allocator,
+            )),
+            IrExpression::Void(e) => IrExpression::Void(Box::new_in(
+                VoidExpr {
+                    expr: Box::new_in(e.expr.clone_in(allocator), allocator),
+                    source_span: e.source_span,
+                },
+                allocator,
+            )),
         }
     }
 }
@@ -1238,6 +1287,61 @@ pub enum IrBinaryOperator {
     NullishCoalesceAssignment,
 }
 
+/// Unary operators for IR expressions.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IrUnaryOperator {
+    /// Unary plus (+)
+    Plus,
+    /// Unary minus (-)
+    Minus,
+}
+
+/// Logical NOT expression (!expr).
+///
+/// Used to preserve pipe bindings inside negation expressions like `!(x | async)`.
+#[derive(Debug)]
+pub struct NotExpr<'a> {
+    /// The operand expression.
+    pub expr: Box<'a, IrExpression<'a>>,
+    /// Source span.
+    pub source_span: Option<Span>,
+}
+
+/// Unary operator expression (+expr or -expr).
+///
+/// Used to preserve pipe bindings inside unary expressions like `+(x | pipe)`.
+#[derive(Debug)]
+pub struct UnaryExpr<'a> {
+    /// The unary operator.
+    pub operator: IrUnaryOperator,
+    /// The operand expression.
+    pub expr: Box<'a, IrExpression<'a>>,
+    /// Source span.
+    pub source_span: Option<Span>,
+}
+
+/// Typeof expression (typeof expr).
+///
+/// Used to preserve pipe bindings inside typeof expressions.
+#[derive(Debug)]
+pub struct TypeofExpr<'a> {
+    /// The operand expression.
+    pub expr: Box<'a, IrExpression<'a>>,
+    /// Source span.
+    pub source_span: Option<Span>,
+}
+
+/// Void expression (void expr).
+///
+/// Used to preserve pipe bindings inside void expressions.
+#[derive(Debug)]
+pub struct VoidExpr<'a> {
+    /// The operand expression.
+    pub expr: Box<'a, IrExpression<'a>>,
+    /// Source span.
+    pub source_span: Option<Span>,
+}
+
 // ============================================================================
 // Expression Transformation
 // ============================================================================
@@ -1372,6 +1476,18 @@ pub fn transform_expressions_in_expression<'a, F>(
             transform_expressions_in_expression(&mut e.true_expr, transform, flags);
             transform_expressions_in_expression(&mut e.false_expr, transform, flags);
         }
+        IrExpression::Not(e) => {
+            transform_expressions_in_expression(&mut e.expr, transform, flags);
+        }
+        IrExpression::Unary(e) => {
+            transform_expressions_in_expression(&mut e.expr, transform, flags);
+        }
+        IrExpression::Typeof(e) => {
+            transform_expressions_in_expression(&mut e.expr, transform, flags);
+        }
+        IrExpression::Void(e) => {
+            transform_expressions_in_expression(&mut e.expr, transform, flags);
+        }
         // These expressions have no internal expressions
         IrExpression::LexicalRead(_)
         | IrExpression::Reference(_)
@@ -1525,6 +1641,18 @@ pub fn visit_expressions_in_expression<'a, F>(
             visit_expressions_in_expression(&e.true_expr, visitor, flags);
             visit_expressions_in_expression(&e.false_expr, visitor, flags);
         }
+        IrExpression::Not(e) => {
+            visit_expressions_in_expression(&e.expr, visitor, flags);
+        }
+        IrExpression::Unary(e) => {
+            visit_expressions_in_expression(&e.expr, visitor, flags);
+        }
+        IrExpression::Typeof(e) => {
+            visit_expressions_in_expression(&e.expr, visitor, flags);
+        }
+        IrExpression::Void(e) => {
+            visit_expressions_in_expression(&e.expr, visitor, flags);
+        }
         // These expressions have no internal expressions
         IrExpression::LexicalRead(_)
         | IrExpression::Reference(_)
@@ -2504,6 +2632,18 @@ pub fn vars_used_by_ir_expression(expr: &IrExpression<'_>) -> u32 {
                 + vars_used_by_ir_expression(&ternary.false_expr)
         }
 
+        // Not expression: vars used by inner expression
+        IrExpression::Not(not) => vars_used_by_ir_expression(&not.expr),
+
+        // Unary expression: vars used by inner expression
+        IrExpression::Unary(unary) => vars_used_by_ir_expression(&unary.expr),
+
+        // Typeof expression: vars used by inner expression
+        IrExpression::Typeof(typeof_expr) => vars_used_by_ir_expression(&typeof_expr.expr),
+
+        // Void expression: vars used by inner expression
+        IrExpression::Void(void_expr) => vars_used_by_ir_expression(&void_expr.expr),
+
         // All other expressions don't directly consume variable slots
         IrExpression::LexicalRead(_)
         | IrExpression::Reference(_)

crates/oxc_angular_compiler/src/parser/html/lexer.rs

@@ -1759,27 +1759,32 @@ impl<'a> HtmlLexer<'a> {
                 self.skip_whitespace();
 
                 if close_tag_name == tag_name && self.peek() == '>' {
-                    // Found the closing tag - emit any accumulated content first
+                    // Found the closing tag - emit any accumulated content first (if non-empty)
                     if consume_entities {
-                        // Emit remaining text (may be empty)
-                        let text = &self.input[text_start as usize..saved_index as usize];
-                        let normalized = normalize_line_endings(text);
-                        self.tokens.push(HtmlToken::with_part(
-                            token_type,
-                            &normalized,
-                            text_start,
-                            saved_index,
-                        ));
+                        // Only emit text token if there is actual content
+                        if text_start < saved_index {
+                            let text = &self.input[text_start as usize..saved_index as usize];
+                            let normalized = normalize_line_endings(text);
+                            self.tokens.push(HtmlToken::with_part(
+                                token_type,
+                                &normalized,
+                                text_start,
+                                saved_index,
+                            ));
+                        }
                     } else {
-                        // For raw text, emit the whole content
-                        let content = &self.input[content_start as usize..saved_index as usize];
-                        let normalized = normalize_line_endings(content);
-                        self.tokens.push(HtmlToken::with_part(
-                            token_type,
-                            &normalized,
-                            content_start,
-                            saved_index,
-                        ));
+                        // For raw text, only emit if there is actual content
+                        if content_start < saved_index {
+                            let content =
+                                &self.input[content_start as usize..saved_index as usize];
+                            let normalized = normalize_line_endings(content);
+                            self.tokens.push(HtmlToken::with_part(
+                                token_type,
+                                &normalized,
+                                content_start,
+                                saved_index,
+                            ));
+                        }
                     }
 
                     // Emit the closing tag
@@ -1801,17 +1806,19 @@ impl<'a> HtmlLexer<'a> {
             }
 
             if self.peek() == chars::EOF {
-                // End of input - emit what we have
+                // End of input - emit what we have (if non-empty)
                 if consume_entities {
-                    let text = &self.input[text_start as usize..self.index as usize];
-                    let normalized = normalize_line_endings(text);
-                    self.tokens.push(HtmlToken::with_part(
-                        token_type,
-                        &normalized,
-                        text_start,
-                        self.index,
-                    ));
-                } else {
+                    if text_start < self.index {
+                        let text = &self.input[text_start as usize..self.index as usize];
+                        let normalized = normalize_line_endings(text);
+                        self.tokens.push(HtmlToken::with_part(
+                            token_type,
+                            &normalized,
+                            text_start,
+                            self.index,
+                        ));
+                    }
+                } else if content_start < self.index {
                     let content = &self.input[content_start as usize..self.index as usize];
                     let normalized = normalize_line_endings(content);
                     self.tokens.push(HtmlToken::with_part(
@@ -1826,15 +1833,17 @@ impl<'a> HtmlLexer<'a> {
 
             // Handle entities for escapable raw text
             if consume_entities && self.peek() == '&' {
-                // Emit any accumulated text before entity (may be empty)
-                let text = &self.input[text_start as usize..self.index as usize];
-                let normalized = normalize_line_endings(text);
-                self.tokens.push(HtmlToken::with_part(
-                    token_type,
-                    &normalized,
-                    text_start,
-                    self.index,
-                ));
+                // Emit any accumulated text before entity (if non-empty)
+                if text_start < self.index {
+                    let text = &self.input[text_start as usize..self.index as usize];
+                    let normalized = normalize_line_endings(text);
+                    self.tokens.push(HtmlToken::with_part(
+                        token_type,
+                        &normalized,
+                        text_start,
+                        self.index,
+                    ));
+                }
 
                 // Try to scan entity
                 if self.scan_entity() {

crates/oxc_angular_compiler/src/pipeline/emit.rs

@@ -1123,6 +1123,60 @@ fn convert_pure_function_body<'a>(
                 allocator,
             ))
         }
+
+        // Not expression: convert operand and wrap in NOT
+        IrExpression::Not(not_expr) => {
+            let inner = convert_pure_function_body(allocator, &not_expr.expr, params);
+            OutputExpression::Not(Box::new_in(
+                crate::output::ast::NotExpr {
+                    condition: Box::new_in(inner, allocator),
+                    source_span: None,
+                },
+                allocator,
+            ))
+        }
+
+        // Unary expression: convert operand and wrap in unary operator
+        IrExpression::Unary(unary) => {
+            let inner = convert_pure_function_body(allocator, &unary.expr, params);
+            let operator = match unary.operator {
+                crate::ir::expression::IrUnaryOperator::Plus => UnaryOperator::Plus,
+                crate::ir::expression::IrUnaryOperator::Minus => UnaryOperator::Minus,
+            };
+            OutputExpression::UnaryOperator(Box::new_in(
+                UnaryOperatorExpr {
+                    operator,
+                    expr: Box::new_in(inner, allocator),
+                    parens: false,
+                    source_span: None,
+                },
+                allocator,
+            ))
+        }
+
+        // Typeof expression: convert operand and wrap in typeof
+        IrExpression::Typeof(typeof_expr) => {
+            let inner = convert_pure_function_body(allocator, &typeof_expr.expr, params);
+            OutputExpression::Typeof(Box::new_in(
+                crate::output::ast::TypeofExpr {
+                    expr: Box::new_in(inner, allocator),
+                    source_span: None,
+                },
+                allocator,
+            ))
+        }
+
+        // Void expression: convert operand and wrap in void
+        IrExpression::Void(void_expr) => {
+            let inner = convert_pure_function_body(allocator, &void_expr.expr, params);
+            OutputExpression::Void(Box::new_in(
+                crate::output::ast::VoidExpr {
+                    expr: Box::new_in(inner, allocator),
+                    source_span: None,
+                },
+                allocator,
+            ))
+        }
     }
 }