fix more cases

Author: Brooooooklyn

crates/oxc_angular_compiler/src/factory/compiler.rs

@@ -18,16 +18,31 @@
 //!   };
 //! })()
 //! ```
+//!
+//! For delegated factories (useFactory/useClass with deps), generates:
+//! ```javascript
+//! function MyService_Factory(__ngFactoryType__) {
+//!   let __ngConditionalFactory__ = null;
+//!   if (__ngFactoryType__) {
+//!     __ngConditionalFactory__ = new (__ngFactoryType__ || MyService)();
+//!   } else {
+//!     __ngConditionalFactory__ = delegatedFactory(ɵɵinject(Dep1), ɵɵinject(Dep2));
+//!   }
+//!   return __ngConditionalFactory__;
+//! }
+//! ```
 
 use oxc_allocator::{Allocator, Box, FromIn, Vec};
 use oxc_span::Atom;
 
-use super::metadata::{FactoryTarget, R3DependencyMetadata, R3FactoryDeps, R3FactoryMetadata};
+use super::metadata::{
+    FactoryTarget, R3DependencyMetadata, R3FactoryDelegateType, R3FactoryDeps, R3FactoryMetadata,
+};
 use crate::output::ast::{
     ArrowFunctionBody, ArrowFunctionExpr, BinaryOperator, BinaryOperatorExpr, DeclareVarStmt,
-    ExpressionStatement, FnParam, FunctionExpr, InstantiateExpr, InvokeFunctionExpr, LiteralExpr,
-    LiteralValue, OutputExpression, OutputStatement, ReadPropExpr, ReadVarExpr, ReturnStatement,
-    StmtModifier,
+    ExpressionStatement, FnParam, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr,
+    LiteralExpr, LiteralValue, OutputExpression, OutputStatement, ReadPropExpr, ReadVarExpr,
+    ReturnStatement, StmtModifier,
 };
 use crate::r3::Identifiers;
 
@@ -68,6 +83,21 @@ pub struct FactoryCompileResult<'a> {
 ///   return new (__ngFactoryType__ || MyClass)(ɵɵdirectiveInject(Dep1));
 /// }
 /// ```
+///
+/// For delegated factories (useFactory/useClass with deps), generates the conditional pattern:
+/// ```javascript
+/// function MyService_Factory(__ngFactoryType__) {
+///   let __ngConditionalFactory__ = null;
+///   if (__ngFactoryType__) {
+///     __ngConditionalFactory__ = new (__ngFactoryType__ || MyService)();
+///   } else {
+///     __ngConditionalFactory__ = delegatedFactory(ɵɵinject(Dep1), ɵɵinject(Dep2));
+///   }
+///   return __ngConditionalFactory__;
+/// }
+/// ```
+///
+/// See: `packages/compiler/src/render3/r3_factory.ts:106-200`
 pub fn compile_factory_function<'a>(
     allocator: &'a Allocator,
     meta: &R3FactoryMetadata<'a>,
@@ -76,67 +106,153 @@ pub fn compile_factory_function<'a>(
     let base = meta.base();
     let factory_type_param = Atom::from("__ngFactoryType__");
 
-    // (__ngFactoryType__ || MyClass)
-    let type_for_ctor = OutputExpression::BinaryOperator(Box::new_in(
-        BinaryOperatorExpr {
-            operator: BinaryOperator::Or,
-            lhs: Box::new_in(
-                OutputExpression::ReadVar(Box::new_in(
-                    ReadVarExpr { name: factory_type_param.clone(), source_span: None },
+    // The type to instantiate via constructor invocation. If there is no delegated factory,
+    // meaning this type is always created by constructor invocation, then this is the
+    // type-to-create parameter provided by the user (t) if specified, or the current type if not.
+    // If there is a delegated factory (which is used to create the current type) then this is
+    // only the type-to-create parameter (t).
+    // See: r3_factory.ts:115-118
+    let type_for_ctor = if meta.is_delegated() {
+        // For delegated factories, only use the type parameter
+        OutputExpression::ReadVar(Box::new_in(
+            ReadVarExpr { name: factory_type_param.clone(), source_span: None },
+            allocator,
+        ))
+    } else {
+        // (__ngFactoryType__ || MyClass)
+        OutputExpression::BinaryOperator(Box::new_in(
+            BinaryOperatorExpr {
+                operator: BinaryOperator::Or,
+                lhs: Box::new_in(
+                    OutputExpression::ReadVar(Box::new_in(
+                        ReadVarExpr { name: factory_type_param.clone(), source_span: None },
+                        allocator,
+                    )),
                     allocator,
-                )),
-                allocator,
-            ),
-            rhs: Box::new_in(base.type_expr.clone_in(allocator), allocator),
-            source_span: None,
-        },
-        allocator,
-    ));
-
-    let mut body: Vec<'a, OutputStatement<'a>> = Vec::new_in(allocator);
+                ),
+                rhs: Box::new_in(base.type_expr.clone_in(allocator), allocator),
+                source_span: None,
+            },
+            allocator,
+        ))
+    };
 
-    // Determine the constructor expression based on deps
-    match &base.deps {
+    // Build the constructor expression based on deps
+    // See: r3_factory.ts:119-129
+    let ctor_expr: Option<OutputExpression<'a>> = match &base.deps {
         R3FactoryDeps::Valid(deps) => {
             // new (type)(ɵɵinject(Dep1), ɵɵinject(Dep2), ...)
             let inject_args = inject_dependencies(allocator, deps.as_slice(), base.target);
-            let ctor_expr = OutputExpression::Instantiate(Box::new_in(
+            Some(OutputExpression::Instantiate(Box::new_in(
                 InstantiateExpr {
-                    class_expr: Box::new_in(type_for_ctor, allocator),
+                    class_expr: Box::new_in(type_for_ctor.clone_in(allocator), allocator),
                     args: inject_args,
                     source_span: None,
                 },
                 allocator,
+            )))
+        }
+        R3FactoryDeps::Invalid => None,
+        R3FactoryDeps::None => {
+            // No constructor - use inherited factory pattern.
+            // This is handled specially below for non-delegated cases.
+            None
+        }
+    };
+
+    // Check if we need inherited factory pattern for non-delegated case with no deps
+    if !meta.is_delegated() && !meta.is_expression() && matches!(&base.deps, R3FactoryDeps::None) {
+        return compile_inherited_factory(allocator, base, factory_name);
+    }
+
+    let mut body: Vec<'a, OutputStatement<'a>> = Vec::new_in(allocator);
+    let ret_expr: Option<OutputExpression<'a>>;
+
+    // Handle the different metadata types
+    // See: r3_factory.ts:145-159
+    match meta {
+        R3FactoryMetadata::Delegated(delegated_meta) => {
+            // This type is created with a delegated factory. If a type parameter is not specified,
+            // call the factory instead.
+            let delegate_args =
+                inject_dependencies(allocator, &delegated_meta.delegate_deps, base.target);
+
+            // Either call `new delegate(...)` or `delegate(...)` depending on delegate_type
+            let factory_expr = match delegated_meta.delegate_type {
+                R3FactoryDelegateType::Class => {
+                    // new delegate(...)
+                    OutputExpression::Instantiate(Box::new_in(
+                        InstantiateExpr {
+                            class_expr: Box::new_in(
+                                delegated_meta.delegate.clone_in(allocator),
+                                allocator,
+                            ),
+                            args: delegate_args,
+                            source_span: None,
+                        },
+                        allocator,
+                    ))
+                }
+                R3FactoryDelegateType::Function => {
+                    // delegate(...)
+                    OutputExpression::InvokeFunction(Box::new_in(
+                        InvokeFunctionExpr {
+                            fn_expr: Box::new_in(
+                                delegated_meta.delegate.clone_in(allocator),
+                                allocator,
+                            ),
+                            args: delegate_args,
+                            pure: false,
+                            source_span: None,
+                        },
+                        allocator,
+                    ))
+                }
+            };
+
+            ret_expr = Some(make_conditional_factory(
+                allocator,
+                &mut body,
+                &factory_type_param,
+                ctor_expr,
+                factory_expr,
             ));
-            // Add return statement
-            body.push(OutputStatement::Return(Box::new_in(
-                ReturnStatement { value: ctor_expr, source_span: None },
+        }
+        R3FactoryMetadata::Expression(expr_meta) => {
+            // useValue or useExisting case
+            ret_expr = Some(make_conditional_factory(
                 allocator,
-            )));
+                &mut body,
+                &factory_type_param,
+                ctor_expr,
+                expr_meta.expression.clone_in(allocator),
+            ));
         }
-        R3FactoryDeps::Invalid => {
-            // Add invalidFactory() call as expression statement (not return).
-            // This matches TypeScript behavior at r3_factory.ts:161-163.
+        R3FactoryMetadata::Constructor(_) => {
+            // Standard constructor case - just use ctor_expr directly
+            ret_expr = ctor_expr;
+        }
+    }
+
+    // Generate the return or invalidFactory call
+    // See: r3_factory.ts:161-177
+    match ret_expr {
+        None => {
+            // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
             let invalid_factory_call = create_invalid_factory_call(allocator);
             body.push(OutputStatement::Expression(Box::new_in(
                 ExpressionStatement { expr: invalid_factory_call, source_span: None },
                 allocator,
             )));
         }
-        R3FactoryDeps::None => {
-            // No constructor - use inherited factory pattern.
-            // Generates:
-            // ```javascript
-            // /*@__PURE__*/ (() => {
-            //   let ɵMyClass_BaseFactory;
-            //   return function MyClass_Factory(__ngFactoryType__) {
-            //     return (ɵMyClass_BaseFactory || (ɵMyClass_BaseFactory = ɵɵgetInheritedFactory(MyClass)))(__ngFactoryType__ || MyClass);
-            //   };
-            // })()
-            // ```
-            return compile_inherited_factory(allocator, base, factory_name);
+        Some(expr) => {
+            // Return the result
+            body.push(OutputStatement::Return(Box::new_in(
+                ReturnStatement { value: expr, source_span: None },
+                allocator,
+            )));
         }
-    };
+    }
 
     // Create the factory function
     let mut params = Vec::new_in(allocator);
@@ -155,6 +271,129 @@ pub fn compile_factory_function<'a>(
     FactoryCompileResult { expression: factory_fn, statements: Vec::new_in(allocator) }
 }
 
+/// Creates the conditional factory pattern for delegated/expression factories.
+///
+/// Generates:
+/// ```javascript
+/// let __ngConditionalFactory__ = null;
+/// if (__ngFactoryType__) {
+///   __ngConditionalFactory__ = <ctor_expr>;  // or invalidFactory() if None
+/// } else {
+///   __ngConditionalFactory__ = <non_ctor_expr>;
+/// }
+/// ```
+///
+/// Returns the `__ngConditionalFactory__` variable reference.
+///
+/// See: `packages/compiler/src/render3/r3_factory.ts:134-143`
+fn make_conditional_factory<'a>(
+    allocator: &'a Allocator,
+    body: &mut Vec<'a, OutputStatement<'a>>,
+    factory_type_param: &Atom<'a>,
+    ctor_expr: Option<OutputExpression<'a>>,
+    non_ctor_expr: OutputExpression<'a>,
+) -> OutputExpression<'a> {
+    let conditional_factory_var = Atom::from("__ngConditionalFactory__");
+
+    // let __ngConditionalFactory__ = null;
+    body.push(OutputStatement::DeclareVar(Box::new_in(
+        DeclareVarStmt {
+            name: conditional_factory_var.clone(),
+            value: Some(OutputExpression::Literal(Box::new_in(
+                LiteralExpr { value: LiteralValue::Null, source_span: None },
+                allocator,
+            ))),
+            modifiers: StmtModifier::NONE,
+            leading_comment: None,
+            source_span: None,
+        },
+        allocator,
+    )));
+
+    // Create the true case: __ngConditionalFactory__ = <ctor_expr> or invalidFactory()
+    let true_stmt = match ctor_expr {
+        Some(expr) => {
+            // __ngConditionalFactory__ = <ctor_expr>
+            let assignment = OutputExpression::BinaryOperator(Box::new_in(
+                BinaryOperatorExpr {
+                    operator: BinaryOperator::Assign,
+                    lhs: Box::new_in(
+                        OutputExpression::ReadVar(Box::new_in(
+                            ReadVarExpr {
+                                name: conditional_factory_var.clone(),
+                                source_span: None,
+                            },
+                            allocator,
+                        )),
+                        allocator,
+                    ),
+                    rhs: Box::new_in(expr, allocator),
+                    source_span: None,
+                },
+                allocator,
+            ));
+            OutputStatement::Expression(Box::new_in(
+                ExpressionStatement { expr: assignment, source_span: None },
+                allocator,
+            ))
+        }
+        None => {
+            // invalidFactory()
+            let invalid_factory_call = create_invalid_factory_call(allocator);
+            OutputStatement::Expression(Box::new_in(
+                ExpressionStatement { expr: invalid_factory_call, source_span: None },
+                allocator,
+            ))
+        }
+    };
+
+    // Create the false case: __ngConditionalFactory__ = <non_ctor_expr>
+    let false_assignment = OutputExpression::BinaryOperator(Box::new_in(
+        BinaryOperatorExpr {
+            operator: BinaryOperator::Assign,
+            lhs: Box::new_in(
+                OutputExpression::ReadVar(Box::new_in(
+                    ReadVarExpr { name: conditional_factory_var.clone(), source_span: None },
+                    allocator,
+                )),
+                allocator,
+            ),
+            rhs: Box::new_in(non_ctor_expr, allocator),
+            source_span: None,
+        },
+        allocator,
+    ));
+    let false_stmt = OutputStatement::Expression(Box::new_in(
+        ExpressionStatement { expr: false_assignment, source_span: None },
+        allocator,
+    ));
+
+    // Create the if statement
+    let mut true_case = Vec::new_in(allocator);
+    true_case.push(true_stmt);
+    let mut false_case = Vec::new_in(allocator);
+    false_case.push(false_stmt);
+
+    body.push(OutputStatement::If(Box::new_in(
+        IfStmt {
+            condition: OutputExpression::ReadVar(Box::new_in(
+                ReadVarExpr { name: factory_type_param.clone(), source_span: None },
+                allocator,
+            )),
+            true_case,
+            false_case,
+            source_span: None,
+        },
+        allocator,
+    )));
+
+    // Return the variable reference
+    OutputExpression::ReadVar(Box::new_in(
+        ReadVarExpr { name: conditional_factory_var, source_span: None },
+        allocator,
+    ))
+}
+
 /// Compiles an inherited factory using the IIFE memoization pattern.
 ///
 /// Generates: