fix(defer): lazy-load an imports entry written as forwardRef(() => X)

crates/oxc_angular_compiler/src/component/decorator.rs

@@ -20,6 +20,7 @@ use super::transform::ImportMap;
 use crate::directive::{
     HostKey, MemberHostBindings, StringConsts, evaluate_host_directives, extract_input_metadata_in,
     extract_output_metadata_in, merge_by_class_property, merge_host_bindings, parse_decorator_io,
+    try_unwrap_forward_ref,
 };
 use crate::output::oxc_converter::convert_oxc_expression;
 use crate::util::is_metadata_property;
@@ -178,6 +179,8 @@ pub fn extract_component_metadata<'a>(
                     // For standalone components, we need:
                     // 1. The identifier list for local analysis
                     metadata.imports = extract_identifier_array(allocator, &prop.value);
+                    metadata.forward_ref_imports =
+                        extract_forward_ref_array(allocator, &prop.value, consts);
                     // 2. The raw expression to pass to ɵɵgetComponentDepsFactory in RuntimeResolved mode
                     metadata.raw_imports =
                         convert_oxc_expression(allocator, &prop.value, source_text);
@@ -487,6 +490,25 @@ fn extract_identifier_array<'a>(
     result
 }
 
+/// The classes an array literal names as `forwardRef(() => X)`, with
+/// `@angular/core`'s `forwardRef`.
+fn extract_forward_ref_array<'a>(
+    allocator: &'a Allocator,
+    expr: &'a Expression<'a>,
+    consts: &StringConsts<'_>,
+) -> Vec<'a, Ident<'a>> {
+    let mut result = Vec::new_in(&allocator);
+    if let Expression::ArrayExpression(arr) = expr {
+        for element in arr.elements.iter().filter_map(ArrayExpressionElement::as_expression) {
+            if let Some(Expression::Identifier(id)) = try_unwrap_forward_ref(element, Some(consts))
+            {
+                result.push(id.name);
+            }
+        }
+    }
+    result
+}
+
 /// Extract ViewEncapsulation from an expression.
 fn extract_encapsulation(expr: &Expression<'_>) -> ViewEncapsulation {
     // Look for patterns like:

crates/oxc_angular_compiler/src/component/metadata.rs

@@ -428,6 +428,12 @@ pub struct ComponentMetadata<'a> {
     /// Component imports (for standalone components).
     pub imports: Vec<'a, Ident<'a>>,
 
+    /// The classes written as `forwardRef(() => X)` (`@angular/core`'s) in
+    /// the `imports` array literal, which [`Self::imports`] leaves out. Only
+    /// read to let `@defer` lazy-load them, as ngtsc resolves them through
+    /// its `forwardRefResolver`.
+    pub forward_ref_imports: Vec<'a, Ident<'a>>,
+
     /// Exported names for template references.
     ///
     /// In Angular, `exportAs` can be a comma-separated string (e.g., "foo, bar"),
@@ -852,6 +858,7 @@ impl<'a> ComponentMetadata<'a> {
             change_detection: None,
             host: None,
             imports: Vec::new_in(&allocator),
+            forward_ref_imports: Vec::new_in(&allocator),
             export_as: Vec::new_in(&allocator),
             preserve_whitespaces: false,
             constructor_deps: None,

crates/oxc_angular_compiler/src/component/transform.rs

@@ -5372,6 +5372,39 @@ fn html_parse_error_diagnostic(
 /// entry refers to, by local name, when `@defer` may lazy-load it.
 type DeferrableSelector<'f> = &'f dyn Fn(&str) -> Option<String>;
 
+/// The class an `imports` entry names: `X`, or `forwardRef(() => X)` when
+/// the decorator analysis resolved it through `@angular/core`'s `forwardRef`
+/// (`forward_refs`), like ngtsc's `forwardRefResolver`.
+fn import_entry_class<'a>(
+    entry: &OutputExpression<'a>,
+    forward_refs: &[Ident<'a>],
+) -> Option<Ident<'a>> {
+    let read_var = |expr: &OutputExpression<'a>| match expr {
+        OutputExpression::ReadVar(var) => Some(var.name),
+        _ => None,
+    };
+    if let Some(name) = read_var(entry) {
+        return Some(name);
+    }
+    let OutputExpression::InvokeFunction(call) = entry else { return None };
+    let statements = match call.args.as_slice() {
+        [OutputExpression::ArrowFunction(arrow)] => match &arrow.body {
+            ArrowFunctionBody::Expression(body) => {
+                return read_var(body).filter(|name| forward_refs.contains(name));
+            }
+            ArrowFunctionBody::Statements(statements) => statements,
+        },
+        [OutputExpression::Function(function)] => &function.statements,
+        _ => return None,
+    };
+    match statements.as_slice() {
+        [OutputStatement::Return(ret)] => {
+            read_var(&ret.value).filter(|name| forward_refs.contains(name))
+        }
+        _ => None,
+    }
+}
+
 fn compile_component_full<'a>(
     allocator: &'a Allocator,
     template: &'a str,
@@ -5552,15 +5585,18 @@ fn compile_component_full<'a>(
         && let Some(import_elision) = import_elision
         && !options.hmr
         && let Some(OutputExpression::LiteralArray(raw_imports)) = &metadata.raw_imports
-        && raw_imports.entries.iter().all(|entry| matches!(entry, OutputExpression::ReadVar(_)))
+        && let Some(entry_classes) = raw_imports
+            .entries
+            .iter()
+            .map(|entry| import_entry_class(entry, &metadata.forward_ref_imports))
+            .collect::<Option<std::vec::Vec<_>>>()
         && super::defer_resolver::template_has_defer_block(&r3_result.nodes)
     {
-        let candidates: Vec<_> = metadata
-            .imports
-            .iter()
+        let candidates: Vec<_> = entry_classes
+            .into_iter()
             .filter_map(|name| {
                 let selector = deferrable_selector(name.as_str())?;
-                Some((*name, crate::pipeline::selector::CssSelector::parse(&selector)))
+                Some((name, crate::pipeline::selector::CssSelector::parse(&selector)))
             })
             .collect();
         let deferred =
@@ -5584,8 +5620,9 @@ fn compile_component_full<'a>(
             let is_deferred = |name: &str| deferred.iter().any(|d| d.as_str() == name);
             metadata.imports.retain(|name| !is_deferred(name.as_str()));
             if let Some(OutputExpression::LiteralArray(raw_imports)) = &mut metadata.raw_imports {
+                let forward_refs = &metadata.forward_ref_imports;
                 raw_imports.entries.retain(|entry| {
-                    !matches!(entry, OutputExpression::ReadVar(var) if is_deferred(var.name.as_str()))
+                    !import_entry_class(entry, forward_refs).is_some_and(|name| is_deferred(&name))
                 });
             }
             implicitly_deferred_imports = deferred.iter().map(ToString::to_string).collect();

crates/oxc_angular_compiler/src/directive/mod.rs

@@ -55,7 +55,7 @@ pub(crate) use property_decorators::{
     angular_class_decorator, angular_member_decorator, angular_param_decorator,
     decorator_written_name, is_angular_core_decorator, parse_decorator_queries,
     try_parse_signal_input, try_parse_signal_model, try_parse_signal_output,
-    unwrap_initializer_api_expr,
+    try_unwrap_forward_ref, unwrap_initializer_api_expr,
 };
 pub use property_decorators::{
     extract_class_queries, extract_content_queries, extract_host_bindings, extract_host_listeners,

crates/oxc_angular_compiler/tests/defer_implicit_imports_test.rs

@@ -223,6 +223,59 @@ export class Parent {}
     assert_lazy(&result.code, "./lazy", "default");
 }
 
+/// Port of ngtsc's `defer_spec.ts`: "should lazy-load dependency referenced
+/// with a fowrardRef".
+#[test]
+fn forward_ref_import_used_only_inside_defer_is_lazy_loaded() {
+    for entry in ["forwardRef(() => LazyCmp)", "forwardRef(() => { return LazyCmp; })"] {
+        let dir = TempDir::new().unwrap();
+        lazy_cmp(&dir);
+        let result = transform(
+            &dir,
+            &format!(
+                r#"
+import {{ Component, forwardRef }} from '@angular/core';
+import {{ LazyCmp }} from './lazy';
+
+@Component({{
+    selector: 'app-parent',
+    imports: [{entry}],
+    template: '@defer {{ <app-lazy/> }}',
+}})
+export class Parent {{}}
+"#
+            ),
+        );
+        let code = &result.code;
+        assert_lazy(code, "./lazy", "LazyCmp");
+        assert!(compact(code).contains("ɵɵdefer(1,0,()=>[import(\"./lazy\")"), "{code}");
+        assert!(compact(code).contains("ɵɵgetComponentDepsFactory(Parent,[])"), "{code}");
+        assert!(!code.contains("import { LazyCmp }"), "{code}");
+    }
+}
+
+#[test]
+fn forward_ref_not_from_angular_core_stays_eager() {
+    let dir = TempDir::new().unwrap();
+    lazy_cmp(&dir);
+    let result = transform(
+        &dir,
+        r#"
+import { Component } from '@angular/core';
+import { forwardRef } from './my-forward-ref';
+import { LazyCmp } from './lazy';
+
+@Component({
+    selector: 'app-parent',
+    imports: [forwardRef(() => LazyCmp)],
+    template: '@defer { <app-lazy/> }',
+})
+export class Parent {}
+"#,
+    );
+    assert_eager(&result.code, "./lazy");
+}
+
 #[test]
 fn import_referenced_elsewhere_in_the_file_stays_eager() {
     let dir = TempDir::new().unwrap();