fix(angular): preserve block-body functions in decorator providers

Block-body arrow functions and function expressions in decorator properties
(e.g., useFactory) were silently having unsupported statements dropped.
Only return and expression statements survived, corrupting the function body
and causing runtime errors.

Add RawSource fallback: when convert_oxc_expression encounters a block-body
arrow with unsupported statement types (const, if, for, try/catch, etc.) or
a function expression, it preserves the complete source text verbatim via
span slicing instead of silently dropping statements.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/class_metadata/builders.rs

@@ -38,7 +38,7 @@ pub fn build_decorator_metadata_array<'a>(
                 ))),
                 Expression::StaticMemberExpression(member) => {
                     // Handle namespaced decorators like ng.Component
-                    convert_oxc_expression(allocator, &member.object).map(|receiver| {
+                    convert_oxc_expression(allocator, &member.object, None).map(|receiver| {
                         OutputExpression::ReadProp(Box::new_in(
                             ReadPropExpr {
                                 receiver: Box::new_in(receiver, allocator),
@@ -77,7 +77,7 @@ pub fn build_decorator_metadata_array<'a>(
             let mut args = AllocVec::new_in(allocator);
             for arg in &call.arguments {
                 let expr = arg.to_expression();
-                if let Some(converted) = convert_oxc_expression(allocator, expr) {
+                if let Some(converted) = convert_oxc_expression(allocator, expr, None) {
                     args.push(converted);
                 }
             }

crates/oxc_angular_compiler/src/component/decorator.rs

@@ -50,6 +50,7 @@ pub fn extract_component_metadata<'a>(
     class: &'a Class<'a>,
     implicit_standalone: bool,
     import_map: &ImportMap<'a>,
+    source_text: Option<&'a str>,
 ) -> Option<ComponentMetadata<'a>> {
     // Get the class name
     let class_name: Ident<'a> = class.id.as_ref()?.name.clone().into();
@@ -130,7 +131,8 @@ pub fn extract_component_metadata<'a>(
                     // 1. The identifier list for local analysis
                     metadata.imports = extract_identifier_array(allocator, &prop.value);
                     // 2. The raw expression to pass to ɵɵgetComponentDepsFactory in RuntimeResolved mode
-                    metadata.raw_imports = convert_oxc_expression(allocator, &prop.value);
+                    metadata.raw_imports =
+                        convert_oxc_expression(allocator, &prop.value, source_text);
                 }
                 "exportAs" => {
                     // exportAs can be comma-separated: "foo, bar"
@@ -150,7 +152,8 @@ pub fn extract_component_metadata<'a>(
                 "animations" => {
                     // Extract animations expression as full OutputExpression
                     // Handles both identifier references and complex array expressions
-                    metadata.animations = convert_oxc_expression(allocator, &prop.value);
+                    metadata.animations =
+                        convert_oxc_expression(allocator, &prop.value, source_text);
                 }
                 "schemas" => {
                     // Extract schemas identifiers (e.g., [CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA])
@@ -159,11 +162,13 @@ pub fn extract_component_metadata<'a>(
                 "providers" => {
                     // Extract providers as full OutputExpression
                     // Handles complex expressions like [{provide: TOKEN, useFactory: Factory}]
-                    metadata.providers = convert_oxc_expression(allocator, &prop.value);
+                    metadata.providers =
+                        convert_oxc_expression(allocator, &prop.value, source_text);
                 }
                 "viewProviders" => {
                     // Extract view providers as full OutputExpression
-                    metadata.view_providers = convert_oxc_expression(allocator, &prop.value);
+                    metadata.view_providers =
+                        convert_oxc_expression(allocator, &prop.value, source_text);
                 }
                 "hostDirectives" => {
                     // Extract host directives array
@@ -1134,9 +1139,13 @@ mod tests {
             };
 
             if let Some(class) = class {
-                if let Some(metadata) =
-                    extract_component_metadata(&allocator, class, implicit_standalone, &import_map)
-                {
+                if let Some(metadata) = extract_component_metadata(
+                    &allocator,
+                    class,
+                    implicit_standalone,
+                    &import_map,
+                    Some(code),
+                ) {
                     found_metadata = Some(metadata);
                     break;
                 }

crates/oxc_angular_compiler/src/component/transform.rs

@@ -1616,9 +1616,13 @@ pub fn transform_angular_file(
             // Compute implicit_standalone based on Angular version
             let implicit_standalone = options.implicit_standalone();
 
-            if let Some(mut metadata) =
-                extract_component_metadata(allocator, class, implicit_standalone, &import_map)
-            {
+            if let Some(mut metadata) = extract_component_metadata(
+                allocator,
+                class,
+                implicit_standalone,
+                &import_map,
+                Some(source),
+            ) {
                 // 3. Resolve external styles and merge into metadata
                 resolve_styles(allocator, &mut metadata, resolved_resources);
 
@@ -1696,7 +1700,8 @@ pub fn transform_angular_file(
 
                             // Check if the class also has an @Injectable decorator.
                             // @Injectable is SHARED precedence and can coexist with @Component.
-                            let has_injectable = extract_injectable_metadata(allocator, class);
+                            let has_injectable =
+                                extract_injectable_metadata(allocator, class, Some(source));
                             if let Some(injectable_metadata) = &has_injectable {
                                 if let Some(span) = find_injectable_decorator_span(class) {
                                     decorator_spans_to_remove.push(span);
@@ -1848,7 +1853,7 @@ pub fn transform_angular_file(
                 // the directive and creating conflicting property definitions (like
                 // ɵfac getters) that interfere with the AOT-compiled assignments.
                 if let Some(mut directive_metadata) =
-                    extract_directive_metadata(allocator, class, implicit_standalone)
+                    extract_directive_metadata(allocator, class, implicit_standalone, Some(source))
                 {
                     // Track decorator span for removal
                     if let Some(span) = find_directive_decorator_span(class) {
@@ -1906,7 +1911,8 @@ pub fn transform_angular_file(
 
                     // Check if the class also has an @Injectable decorator.
                     // @Injectable is SHARED precedence and can coexist with @Directive.
-                    let has_injectable = extract_injectable_metadata(allocator, class);
+                    let has_injectable =
+                        extract_injectable_metadata(allocator, class, Some(source));
                     if let Some(injectable_metadata) = &has_injectable {
                         if let Some(span) = find_injectable_decorator_span(class) {
                             decorator_spans_to_remove.push(span);
@@ -1939,7 +1945,7 @@ pub fn transform_angular_file(
                     class_definitions
                         .insert(class_name, (property_assignments, String::new(), String::new()));
                 } else if let Some(mut pipe_metadata) =
-                    extract_pipe_metadata(allocator, class, implicit_standalone)
+                    extract_pipe_metadata(allocator, class, implicit_standalone, Some(source))
                 {
                     // Not a @Component or @Directive - check if it's a @Pipe (PRIMARY)
                     // We need to compile @Pipe classes to generate ɵpipe and ɵfac definitions.
@@ -1980,7 +1986,8 @@ pub fn transform_angular_file(
 
                         // Check if the class also has an @Injectable decorator (issue #65).
                         // @Injectable is SHARED precedence and can coexist with @Pipe.
-                        let has_injectable = extract_injectable_metadata(allocator, class);
+                        let has_injectable =
+                            extract_injectable_metadata(allocator, class, Some(source));
                         if let Some(injectable_metadata) = &has_injectable {
                             if let Some(span) = find_injectable_decorator_span(class) {
                                 decorator_spans_to_remove.push(span);
@@ -2017,7 +2024,7 @@ pub fn transform_angular_file(
                         );
                     }
                 } else if let Some(mut ng_module_metadata) =
-                    extract_ng_module_metadata(allocator, class)
+                    extract_ng_module_metadata(allocator, class, Some(source))
                 {
                     // Not a @Component, @Directive, @Injectable, or @Pipe - check if it's an @NgModule
                     // We need to compile @NgModule classes to generate ɵmod, ɵfac, and ɵinj definitions.
@@ -2061,7 +2068,8 @@ pub fn transform_angular_file(
 
                         // Check if the class also has an @Injectable decorator.
                         // @Injectable is SHARED precedence and can coexist with @NgModule.
-                        let has_injectable = extract_injectable_metadata(allocator, class);
+                        let has_injectable =
+                            extract_injectable_metadata(allocator, class, Some(source));
                         if let Some(injectable_metadata) = &has_injectable {
                             if let Some(span) = find_injectable_decorator_span(class) {
                                 decorator_spans_to_remove.push(span);
@@ -2108,7 +2116,7 @@ pub fn transform_angular_file(
                         );
                     }
                 } else if let Some(mut injectable_metadata) =
-                    extract_injectable_metadata(allocator, class)
+                    extract_injectable_metadata(allocator, class, Some(source))
                 {
                     // Standalone @Injectable (no PRIMARY decorator on the class)
                     // We need to compile @Injectable classes to generate ɵprov and ɵfac definitions.

crates/oxc_angular_compiler/src/directive/decorator.rs

@@ -77,6 +77,7 @@ pub fn extract_directive_metadata<'a>(
     allocator: &'a Allocator,
     class: &'a Class<'a>,
     implicit_standalone: bool,
+    source_text: Option<&'a str>,
 ) -> Option<R3DirectiveMetadata<'a>> {
     // Get the class name
     let class_name: Ident<'a> = class.id.as_ref()?.name.clone().into();
@@ -142,7 +143,9 @@ pub fn extract_directive_metadata<'a>(
                         }
                     }
                     "providers" => {
-                        if let Some(providers) = convert_oxc_expression(allocator, &prop.value) {
+                        if let Some(providers) =
+                            convert_oxc_expression(allocator, &prop.value, source_text)
+                        {
                             builder = builder.providers(providers);
                         }
                     }
@@ -180,7 +183,7 @@ pub fn extract_directive_metadata<'a>(
     // Extract constructor dependencies for factory generation
     // This enables proper DI for directive constructors
     // See: packages/compiler-cli/src/ngtsc/annotations/common/src/di.ts
-    let constructor_deps = extract_constructor_deps(allocator, class, has_superclass);
+    let constructor_deps = extract_constructor_deps(allocator, class, has_superclass, source_text);
     if let Some(deps) = constructor_deps {
         builder = builder.deps(deps);
     }
@@ -252,6 +255,7 @@ fn extract_constructor_deps<'a>(
     allocator: &'a Allocator,
     class: &'a Class<'a>,
     has_superclass: bool,
+    source_text: Option<&'a str>,
 ) -> Option<Vec<'a, R3DependencyMetadata<'a>>> {
     // Find the constructor method
     let constructor = class.body.body.iter().find_map(|element| {
@@ -270,7 +274,7 @@ fn extract_constructor_deps<'a>(
             let mut deps = Vec::with_capacity_in(params.items.len(), allocator);
 
             for param in &params.items {
-                let dep = extract_param_dependency(allocator, param);
+                let dep = extract_param_dependency(allocator, param, source_text);
                 deps.push(dep);
             }
 
@@ -290,6 +294,7 @@ fn extract_constructor_deps<'a>(
 fn extract_param_dependency<'a>(
     allocator: &'a Allocator,
     param: &oxc_ast::ast::FormalParameter<'a>,
+    source_text: Option<&'a str>,
 ) -> R3DependencyMetadata<'a> {
     // Extract flags and @Inject token from decorators
     let mut optional = false;
@@ -306,7 +311,8 @@ fn extract_param_dependency<'a>(
                     // @Inject(TOKEN) - extract the token
                     if let Expression::CallExpression(call) = &decorator.expression {
                         if let Some(arg) = call.arguments.first() {
-                            inject_token = convert_oxc_expression(allocator, arg.to_expression());
+                            inject_token =
+                                convert_oxc_expression(allocator, arg.to_expression(), source_text);
                         }
                     }
                 }
@@ -885,7 +891,7 @@ mod tests {
 
             if let Some(class) = class {
                 if let Some(metadata) =
-                    extract_directive_metadata(&allocator, class, implicit_standalone)
+                    extract_directive_metadata(&allocator, class, implicit_standalone, Some(code))
                 {
                     found_metadata = Some(metadata);
                     break;

crates/oxc_angular_compiler/src/directive/property_decorators.rs

@@ -183,7 +183,7 @@ fn parse_input_config<'a>(
                             config.required = extract_boolean_value(&prop.value).unwrap_or(false);
                         }
                         "transform" => {
-                            config.transform = convert_oxc_expression(allocator, &prop.value);
+                            config.transform = convert_oxc_expression(allocator, &prop.value, None);
                         }
                         _ => {}
                     }
@@ -779,7 +779,7 @@ fn parse_query_config<'a>(
             let expr = first_arg.to_expression();
             // Unwrap forwardRef if present - Angular doesn't include forwardRef in compiled output
             let unwrapped_expr = try_unwrap_forward_ref(expr).unwrap_or(expr);
-            if let Some(output_expr) = convert_oxc_expression(allocator, unwrapped_expr) {
+            if let Some(output_expr) = convert_oxc_expression(allocator, unwrapped_expr, None) {
                 config.predicate = Some(QueryPredicate::Type(output_expr));
             }
         }
@@ -799,7 +799,7 @@ fn parse_query_config<'a>(
                             config.is_static = extract_boolean_value(&prop.value).unwrap_or(false);
                         }
                         "read" => {
-                            config.read = convert_oxc_expression(allocator, &prop.value);
+                            config.read = convert_oxc_expression(allocator, &prop.value, None);
                         }
                         "descendants" => {
                             // Use the decorator-specific default if not explicitly set
@@ -941,7 +941,7 @@ fn try_parse_signal_query<'a>(
             let expr = predicate_arg.to_expression();
             // Unwrap forwardRef if present - Angular doesn't include forwardRef in compiled output
             let unwrapped_expr = try_unwrap_forward_ref(expr).unwrap_or(expr);
-            let output_expr = convert_oxc_expression(allocator, unwrapped_expr)?;
+            let output_expr = convert_oxc_expression(allocator, unwrapped_expr, None)?;
             QueryPredicate::Type(output_expr)
         }
     };
@@ -960,7 +960,7 @@ fn try_parse_signal_query<'a>(
 
                     match key_name.as_str() {
                         "read" => {
-                            read = convert_oxc_expression(allocator, &prop.value);
+                            read = convert_oxc_expression(allocator, &prop.value, None);
                         }
                         "descendants" => {
                             descendants = extract_boolean_value(&prop.value).unwrap_or(descendants);