save

Author: Brooooooklyn

Cargo.lock

@@ -27,10 +27,11 @@ rustc-hash = { workspace = true }
 lazy-regex = { workspace = true }
 indexmap = { workspace = true }
 oxc_resolver = { version = "11", optional = true }
+pathdiff = { version = "0.2", optional = true }
 
 [features]
 default = []
-cross_file_elision = ["oxc_resolver"]
+cross_file_elision = ["oxc_resolver", "pathdiff"]
 
 [dev-dependencies]
 insta = { workspace = true, features = ["glob"] }

crates/oxc_angular_compiler/Cargo.toml

@@ -1088,6 +1088,48 @@ pub fn collect_member_decorator_spans(class: &Class<'_>, spans: &mut std::vec::V
     }
 }
 
+/// Collect spans of uninitialized class field declarations for stripping.
+///
+/// TypeScript class field declarations like `name: string;` without initializers are
+/// type-only annotations that have no runtime effect. They should be stripped from
+/// the output to match TypeScript's emit behavior.
+///
+/// Only collects:
+/// - Non-static property definitions without an initializer (e.g., `name: string;`)
+///
+/// Does NOT collect:
+/// - Fields with initializers (e.g., `name = 'value';`) - these have runtime values
+/// - Static fields (e.g., `static version: string;`) - handled separately
+/// - Methods or accessors - they have runtime bodies
+/// - Decorated fields - Angular may need the field structure
+///
+/// These spans are used by `transform.rs` to remove the declarations from the
+/// source text during transformation.
+pub fn collect_uninitialized_field_spans(class: &Class<'_>, spans: &mut std::vec::Vec<Span>) {
+    for element in &class.body.body {
+        if let ClassElement::PropertyDefinition(prop) = element {
+            // Skip static fields - they're handled differently
+            if prop.r#static {
+                continue;
+            }
+
+            // Skip fields with initializers - they have runtime values
+            if prop.value.is_some() {
+                continue;
+            }
+
+            // Skip decorated fields - Angular may need them
+            if !prop.decorators.is_empty() {
+                continue;
+            }
+
+            // This is an uninitialized, non-static, non-decorated field declaration
+            // (e.g., `name: string;`) - it should be stripped
+            spans.push(prop.span);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1109,7 +1151,7 @@ mod tests {
         let parser_ret = Parser::new(&allocator, code, source_type).parse();
 
         // Build import map from the program body
-        let import_map = build_import_map(&parser_ret.program.body);
+        let import_map = build_import_map(&allocator, &parser_ret.program.body, None);
 
         // Find the first class declaration (handles plain, export default, and export named)
         let mut found_metadata = None;

crates/oxc_angular_compiler/src/component/cross_file_elision.rs

@@ -50,6 +50,25 @@ use rustc_hash::FxHashSet;
 /// Reference: packages/compiler-cli/src/ngtsc/annotations/common/src/di.ts
 const PARAM_DECORATORS: &[&str] = &["Inject", "Optional", "Self", "SkipSelf", "Host", "Attribute"];
 
+/// Angular member decorators that are removed during compilation.
+/// These decorators are compiled into the component/directive definition and their
+/// imports can be elided. They are used on class properties and methods.
+///
+/// Reference: packages/compiler-cli/src/ngtsc/annotations/directive/src/decorator.ts
+const MEMBER_DECORATORS: &[&str] = &[
+    // Property decorators
+    "Input",
+    "Output",
+    "HostBinding",
+    // Method decorators
+    "HostListener",
+    // Query decorators
+    "ViewChild",
+    "ViewChildren",
+    "ContentChild",
+    "ContentChildren",
+];
+
 /// Analyzer for determining which imports are type-only and can be elided.
 pub struct ImportElisionAnalyzer<'a> {
     /// Set of import specifier local names that should be removed (type-only).
@@ -123,26 +142,27 @@ impl<'a> ImportElisionAnalyzer<'a> {
         Self { type_only_specifiers }
     }
 
-    /// Collect import names that are used ONLY in constructor parameter decorators.
+    /// Collect import names that are used ONLY in Angular decorators that are removed during compilation.
     ///
-    /// Constructor parameter decorators like `@Inject`, `@Optional`, `@Self`, `@SkipSelf`,
-    /// `@Host`, and `@Attribute` are removed by Angular's compiler and converted to
-    /// factory metadata. The imports for these decorators and their arguments (like
-    /// `@Inject(TOKEN)`) should be elided.
+    /// This includes:
+    /// - Constructor parameter decorators (`@Inject`, `@Optional`, `@Self`, `@SkipSelf`, `@Host`, `@Attribute`)
+    /// - Member decorators (`@Input`, `@Output`, `@HostBinding`, `@HostListener`, `@ViewChild`, etc.)
     ///
-    /// This function returns a set of local import names that should be elided because:
-    /// 1. The import is a known parameter decorator (Inject, Optional, etc.)
-    /// 2. The import is ONLY used as an argument to @Inject()
+    /// These decorators are compiled into the component/directive definition by Angular's compiler,
+    /// so their imports can be elided.
     ///
     /// Reference: packages/compiler-cli/src/ngtsc/transform/jit/src/downlevel_decorators_transform.ts
     fn collect_ctor_param_decorator_only_imports(program: &'a Program<'a>) -> FxHashSet<&'a str> {
         let mut result = FxHashSet::default();
 
         // Track:
-        // 1. Symbols used ONLY in ctor param decorator position (the decorator itself)
-        // 2. Symbols used ONLY as @Inject() arguments
+        // 1. Symbols used in ctor param decorator position (the decorator itself)
+        // 2. Symbols used as @Inject() arguments
+        // 3. Symbols used in member decorator position (property/method decorators)
+        // 4. Symbols used in other value positions (can't be elided)
         let mut ctor_param_decorator_uses: FxHashSet<&'a str> = FxHashSet::default();
         let mut inject_arg_uses: FxHashSet<&'a str> = FxHashSet::default();
+        let mut member_decorator_uses: FxHashSet<&'a str> = FxHashSet::default();
         let mut other_value_uses: FxHashSet<&'a str> = FxHashSet::default();
 
         // Walk the AST to find constructor parameters and their decorators
@@ -151,13 +171,12 @@ impl<'a> ImportElisionAnalyzer<'a> {
                 stmt,
                 &mut ctor_param_decorator_uses,
                 &mut inject_arg_uses,
+                &mut member_decorator_uses,
                 &mut other_value_uses,
             );
         }
 
-        // A symbol can be elided if:
-        // 1. It's used in ctor param decorators AND NOT used elsewhere, OR
-        // 2. It's used in @Inject() args AND NOT used elsewhere
+        // A symbol can be elided if it's used only in decorator positions and NOT used elsewhere
         for name in ctor_param_decorator_uses {
             if !other_value_uses.contains(name) {
                 result.insert(name);
@@ -168,6 +187,11 @@ impl<'a> ImportElisionAnalyzer<'a> {
                 result.insert(name);
             }
         }
+        for name in member_decorator_uses {
+            if !other_value_uses.contains(name) {
+                result.insert(name);
+            }
+        }
 
         result
     }
@@ -177,6 +201,7 @@ impl<'a> ImportElisionAnalyzer<'a> {
         stmt: &'a Statement<'a>,
         ctor_param_decorator_uses: &mut FxHashSet<&'a str>,
         inject_arg_uses: &mut FxHashSet<&'a str>,
+        member_decorator_uses: &mut FxHashSet<&'a str>,
         other_value_uses: &mut FxHashSet<&'a str>,
     ) {
         match stmt {
@@ -185,6 +210,7 @@ impl<'a> ImportElisionAnalyzer<'a> {
                     class,
                     ctor_param_decorator_uses,
                     inject_arg_uses,
+                    member_decorator_uses,
                     other_value_uses,
                 );
             }
@@ -196,6 +222,7 @@ impl<'a> ImportElisionAnalyzer<'a> {
                         class,
                         ctor_param_decorator_uses,
                         inject_arg_uses,
+                        member_decorator_uses,
                         other_value_uses,
                     );
                 }
@@ -207,6 +234,7 @@ impl<'a> ImportElisionAnalyzer<'a> {
                         class,
                         ctor_param_decorator_uses,
                         inject_arg_uses,
+                        member_decorator_uses,
                         other_value_uses,
                     );
                 }
@@ -232,6 +260,7 @@ impl<'a> ImportElisionAnalyzer<'a> {
         class: &'a oxc_ast::ast::Class<'a>,
         ctor_param_decorator_uses: &mut FxHashSet<&'a str>,
         inject_arg_uses: &mut FxHashSet<&'a str>,
+        member_decorator_uses: &mut FxHashSet<&'a str>,
         other_value_uses: &mut FxHashSet<&'a str>,
     ) {
         // Process class decorators - these are NOT elided (they run at runtime)
@@ -243,9 +272,14 @@ impl<'a> ImportElisionAnalyzer<'a> {
         for element in &class.body.body {
             match element {
                 ClassElement::MethodDefinition(method) => {
-                    // Process method decorators (e.g., @HostListener) - NOT elided
+                    // Process method decorators (e.g., @HostListener)
+                    // Angular member decorators are elided; other decorators are kept
                     for decorator in &method.decorators {
-                        Self::collect_value_uses_from_expr(&decorator.expression, other_value_uses);
+                        Self::collect_uses_from_member_decorator(
+                            &decorator.expression,
+                            member_decorator_uses,
+                            other_value_uses,
+                        );
                     }
 
                     if method.kind == MethodDefinitionKind::Constructor {
@@ -258,9 +292,14 @@ impl<'a> ImportElisionAnalyzer<'a> {
                     }
                 }
                 ClassElement::PropertyDefinition(prop) => {
-                    // Process property decorators (e.g., @Input, @ViewChild) - NOT elided
+                    // Process property decorators (e.g., @Input, @ViewChild, @HostBinding)
+                    // Angular member decorators are elided; other decorators are kept
                     for decorator in &prop.decorators {
-                        Self::collect_value_uses_from_expr(&decorator.expression, other_value_uses);
+                        Self::collect_uses_from_member_decorator(
+                            &decorator.expression,
+                            member_decorator_uses,
+                            other_value_uses,
+                        );
                     }
                     // Process property initializers (e.g., doc = DOCUMENT)
                     if let Some(init) = &prop.value {
@@ -269,14 +308,56 @@ impl<'a> ImportElisionAnalyzer<'a> {
                 }
                 ClassElement::AccessorProperty(prop) => {
                     for decorator in &prop.decorators {
-                        Self::collect_value_uses_from_expr(&decorator.expression, other_value_uses);
+                        Self::collect_uses_from_member_decorator(
+                            &decorator.expression,
+                            member_decorator_uses,
+                            other_value_uses,
+                        );
                     }
                 }
                 _ => {}
             }
         }
     }
 
+    /// Collect uses from a member decorator expression.
+    ///
+    /// Angular member decorators like `@Input`, `@Output`, `@HostBinding`, `@HostListener`, etc.
+    /// are compiled into the component/directive definition and can be elided.
+    /// Non-Angular decorators are tracked as "other value uses" and are not elided.
+    fn collect_uses_from_member_decorator(
+        expr: &'a Expression<'a>,
+        member_decorator_uses: &mut FxHashSet<&'a str>,
+        other_value_uses: &mut FxHashSet<&'a str>,
+    ) {
+        let decorator_name = match expr {
+            // @HostBinding (without call)
+            Expression::Identifier(id) => Some(id.name.as_str()),
+            // @HostBinding('class.active') or @Input()
+            Expression::CallExpression(call) => {
+                if let Expression::Identifier(id) = &call.callee {
+                    Some(id.name.as_str())
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        };
+
+        if let Some(name) = decorator_name {
+            // Check if this is a known Angular member decorator that can be elided
+            if MEMBER_DECORATORS.contains(&name) {
+                member_decorator_uses.insert(name);
+            } else {
+                // Non-Angular decorator - treat as value use (not elided)
+                Self::collect_value_uses_from_expr(expr, other_value_uses);
+            }
+        } else {
+            // Fallback: collect as value use
+            Self::collect_value_uses_from_expr(expr, other_value_uses);
+        }
+    }
+
     /// Collect uses from constructor parameters.
     ///
     /// This is the key function that identifies parameter decorators and their arguments.
@@ -667,6 +748,15 @@ pub fn filter_imports<'a>(
 
     let mut result = source.to_string();
     for (start, end, replacement) in all_operations {
+        // Validate that positions are within bounds and on UTF-8 character boundaries
+        if start > result.len()
+            || end > result.len()
+            || !result.is_char_boundary(start)
+            || !result.is_char_boundary(end)
+        {
+            // Skip this operation - it's invalid for the current source state
+            continue;
+        }
         result.replace_range(start..end, &replacement);
     }
 
@@ -717,9 +807,10 @@ class MyComponent {
 }
 "#;
         let type_only = analyze_source(source);
-        // Component and Input are used in decorators (value position)
+        // Component is used as class decorator - preserved
         assert!(!type_only.contains("Component"));
-        assert!(!type_only.contains("Input"));
+        // Input is a member decorator - elided (compiled into definition)
+        assert!(type_only.contains("Input"), "Input should be elided (member decorator)");
     }
 
     #[test]
@@ -1001,9 +1092,11 @@ class MyComponent {
             "Translation in type annotation should be elided"
         );
 
-        // Component and Input are used as decorators - value references, preserved
+        // Component is the class decorator - preserved
         assert!(!type_only.contains("Component"));
-        assert!(!type_only.contains("Input"));
+
+        // Input is a member decorator - elided (compiled into definition)
+        assert!(type_only.contains("Input"), "Input should be elided (member decorator)");
     }
 
     #[test]
@@ -1418,11 +1511,14 @@ export class BitLabelComponent {
             "FormControlComponent should be elided (type annotation)"
         );
 
-        // Component, HostBinding, Input, input should be preserved (runtime decorators/values)
+        // Component and input (function call) should be preserved (runtime decorators/values)
+        // Note: Component is used as class decorator, input() is a function call
         assert!(!type_only.contains("Component"), "Component should be preserved");
-        assert!(!type_only.contains("HostBinding"), "HostBinding should be preserved");
-        assert!(!type_only.contains("Input"), "Input should be preserved");
         assert!(!type_only.contains("input"), "input function should be preserved");
+
+        // HostBinding and Input should be elided (member decorators are compiled away)
+        assert!(type_only.contains("HostBinding"), "HostBinding should be elided (member decorator)");
+        assert!(type_only.contains("Input"), "Input should be elided (member decorator)");
     }
 
     #[test]
@@ -1459,12 +1555,14 @@ export class BitLabelComponent {
             import_line
         );
 
-        // Should still contain Component, HostBinding, Input, input
+        // Component and input (function call) should be in imports
         assert!(import_line.contains("Component"), "Component should be in imports");
-        assert!(import_line.contains("HostBinding"), "HostBinding should be in imports");
-        assert!(import_line.contains("Input"), "Input should be in imports");
         assert!(import_line.contains("input"), "input should be in imports");
 
+        // Member decorators should be removed (they're compiled into the definition)
+        assert!(!import_line.contains("HostBinding"), "HostBinding should be removed from imports");
+        assert!(!import_line.contains("Input"), "Input should be removed from imports");
+
         // Should NOT contain ElementRef (type annotation)
         assert!(
             !import_line.contains("ElementRef"),