fix test runner

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/definition.rs

@@ -29,7 +29,6 @@ use crate::output::ast::{
 };
 use crate::pipeline::compilation::{ComponentCompilationJob, ConstValue};
 use crate::pipeline::emit::HostBindingCompilationResult;
-use crate::pipeline::selector::CssSelector;
 
 /// Result of generating component definitions.
 pub struct ComponentDefinitions<'a> {
@@ -49,6 +48,8 @@ pub struct ComponentDefinitions<'a> {
 /// * `job` - The compilation job with template compilation results
 /// * `template_fn` - The compiled template function
 /// * `host_binding_result` - Optional host binding compilation result (function, hostAttrs, hostVars)
+/// * `attrs_ref` - Optional pre-pooled attrs constant reference (pooled before template compilation)
+/// * `view_query_fn` - Optional view query function (with pre-pooled predicates)
 ///
 /// # Returns
 ///
@@ -59,9 +60,18 @@ pub fn generate_component_definitions<'a>(
     job: &mut ComponentCompilationJob<'a>,
     template_fn: FunctionExpr<'a>,
     host_binding_result: Option<HostBindingCompilationResult<'a>>,
+    attrs_ref: Option<OutputExpression<'a>>,
+    view_query_fn: Option<OutputExpression<'a>>,
 ) -> ComponentDefinitions<'a> {
-    let cmp_definition =
-        generate_cmp_definition(allocator, metadata, job, template_fn, host_binding_result);
+    let cmp_definition = generate_cmp_definition(
+        allocator,
+        metadata,
+        job,
+        template_fn,
+        host_binding_result,
+        attrs_ref,
+        view_query_fn,
+    );
     let fac_definition = generate_fac_definition(allocator, metadata);
 
     ComponentDefinitions { cmp_definition, fac_definition }
@@ -88,6 +98,8 @@ fn generate_cmp_definition<'a>(
     job: &mut ComponentCompilationJob<'a>,
     template_fn: FunctionExpr<'a>,
     host_binding_result: Option<HostBindingCompilationResult<'a>>,
+    attrs_ref: Option<OutputExpression<'a>>,
+    view_query_fn: Option<OutputExpression<'a>>,
 ) -> OutputExpression<'a> {
     let mut entries: OxcVec<'a, LiteralMapEntry<'a>> = OxcVec::new_in(allocator);
 
@@ -109,35 +121,15 @@ fn generate_cmp_definition<'a>(
             value: selector_entries,
             quoted: false,
         });
+    }
 
-        // attrs: ["class", "..."] - only if first selector has attributes
-        // This is optional and only included if the first selector specifies attributes.
-        // Ported from Angular compiler.ts lines 195-212.
-        let parsed_selectors = CssSelector::parse(selector);
-        if let Some(first_selector) = parsed_selectors.first() {
-            let selector_attrs = first_selector.get_attrs();
-            if !selector_attrs.is_empty() {
-                let mut attr_entries: OxcVec<'a, OutputExpression<'a>> =
-                    OxcVec::with_capacity_in(selector_attrs.len(), allocator);
-                for attr in selector_attrs {
-                    attr_entries.push(OutputExpression::Literal(Box::new_in(
-                        LiteralExpr {
-                            value: LiteralValue::String(Atom::from_in(attr.as_str(), allocator)),
-                            source_span: None,
-                        },
-                        allocator,
-                    )));
-                }
-                entries.push(LiteralMapEntry {
-                    key: Atom::from("attrs"),
-                    value: OutputExpression::LiteralArray(Box::new_in(
-                        LiteralArrayExpr { entries: attr_entries, source_span: None },
-                        allocator,
-                    )),
-                    quoted: false,
-                });
-            }
-        }
+    // attrs: ["class", "..."] - only if first selector has attributes
+    // This is optional and only included if the first selector specifies attributes.
+    // Ported from Angular compiler.ts lines 195-212.
+    // The attrs_ref is pre-pooled BEFORE template compilation to ensure correct constant ordering.
+    // TypeScript Angular adds attrs to the pool BEFORE template ingestion/compilation.
+    if let Some(attrs) = attrs_ref {
+        entries.push(LiteralMapEntry { key: Atom::from("attrs"), value: attrs, quoted: false });
     }
 
     // standalone: true/false
@@ -331,6 +323,17 @@ fn generate_cmp_definition<'a>(
         }
     }
 
+    // viewQuery: function(rf, ctx) { ... } (if any)
+    // This handles @ViewChild/@ViewChildren decorators.
+    // The predicate arrays are pre-pooled to ensure correct constant ordering.
+    if let Some(view_query) = view_query_fn {
+        entries.push(LiteralMapEntry {
+            key: Atom::from("viewQuery"),
+            value: view_query,
+            quoted: false,
+        });
+    }
+
     // consts: [...] or consts: function() { ...initializers...; return [...]; }
     // Per Angular compiler.ts lines 260-268:
     // - If there are const initializers (e.g., for i18n dual-mode), wrap in arrow function

crates/oxc_angular_compiler/src/component/transform.rs

@@ -18,7 +18,8 @@ use super::metadata::{AngularVersion, ComponentMetadata, HostMetadata};
 use crate::ast::expression::{BindingType, ParsedEventType};
 use crate::ast::r3::{R3BoundAttribute, R3BoundEvent, SecurityContext};
 use crate::directive::{
-    extract_directive_metadata, find_directive_decorator_span, generate_directive_definitions,
+    R3QueryMetadata, create_view_queries_function, extract_directive_metadata,
+    extract_view_queries, find_directive_decorator_span, generate_directive_definitions,
 };
 use crate::injectable::{
     extract_injectable_metadata, find_injectable_decorator_span,
@@ -331,6 +332,13 @@ pub fn transform_angular_file(
     let mut decorator_spans_to_remove: Vec<Span> = Vec::new();
     let mut needs_angular_core_import = false;
 
+    // Shared constant pool index across all components in this file.
+    // This ensures constant names (_c0, _c1, etc.) don't conflict when
+    // multiple components are compiled in the same file.
+    // TypeScript Angular uses ONE file-level constant pool; we simulate this
+    // by tracking the next index and passing it to each component.
+    let mut shared_pool_index: u32 = 0;
+
     // 2. Walk AST to find @Component decorated classes and extract metadata
     for stmt in &parser_ret.program.body {
         let class = match stmt {
@@ -361,10 +369,25 @@ pub fn transform_angular_file(
                 let class_name = metadata.class_name.to_string();
 
                 if let Some(template) = template_source {
+                    // 4.5 Extract view queries from the class (for @ViewChild/@ViewChildren)
+                    // These need to be passed to compile_component_full so predicates can be pooled
+                    let view_queries = extract_view_queries(allocator, class);
+
                     // 4. Compile the template and generate ɵcmp/ɵfac
-                    match compile_component_full(allocator, &template, &mut metadata, path, options)
-                    {
+                    // Pass the shared pool index to ensure unique constant names
+                    match compile_component_full(
+                        allocator,
+                        &template,
+                        &mut metadata,
+                        path,
+                        options,
+                        view_queries,
+                        shared_pool_index,
+                    ) {
                         Ok(compilation_result) => {
+                            // Update the shared pool index for the next component
+                            shared_pool_index = compilation_result.next_pool_index;
+
                             let component_id = format!("{}@{}", path, class_name);
 
                             // Store for HMR if enabled
@@ -623,15 +646,25 @@ struct FullCompilationResult {
 
     /// HMR initialization code (if HMR is enabled).
     hmr_initializer_js: Option<String>,
+
+    /// The next constant pool index to use for the next component.
+    /// This is used to share pool state across multiple components in the same file.
+    next_pool_index: u32,
 }
 
 /// Compile a component template and generate ɵcmp/ɵfac definitions.
+///
+/// The `pool_starting_index` parameter is used to ensure constant names don't conflict
+/// when compiling multiple components in the same file. Each component continues from
+/// where the previous component's pool left off.
 fn compile_component_full<'a>(
     allocator: &'a Allocator,
     template: &'a str,
     metadata: &mut ComponentMetadata<'a>,
     file_path: &str,
     options: &TransformOptions,
+    view_queries: OxcVec<'a, R3QueryMetadata<'a>>,
+    pool_starting_index: u32,
 ) -> Result<FullCompilationResult, Vec<OxcDiagnostic>> {
     use oxc_allocator::FromIn;
 
@@ -734,6 +767,9 @@ fn compile_component_full<'a>(
         // In PerComponent mode, this would be provided by the build tool
         // For now, we don't have a way to pass it from NAPI, so it's None
         all_deferrable_deps_fn: None,
+        // Use the shared pool starting index to avoid duplicate constant names
+        // when compiling multiple components in the same file
+        pool_starting_index,
     };
 
     let mut job = ingest_component_with_options(
@@ -742,18 +778,43 @@ fn compile_component_full<'a>(
         r3_result.nodes,
         ingest_options,
     );
+
+    // BEFORE template compilation: Pool attrs const if first selector has attributes.
+    // This matches TypeScript Angular which adds attrs to the pool BEFORE template ingestion.
+    // By pooling attrs first, it gets _c0 (or the first available index).
+    // See: packages/compiler/src/render3/view/compiler.ts lines 192-212
+    let attrs_ref = pool_selector_attrs(allocator, &mut job, metadata);
+
+    // BEFORE template compilation: Pool view query predicates.
+    // TypeScript Angular pools query predicates BEFORE template compilation and pure functions.
+    // This ensures correct constant ordering: attrs -> query predicates -> pure functions.
+    let view_query_fn = if !view_queries.is_empty() {
+        let fn_name = Some(metadata.class_name.as_str());
+        Some(create_view_queries_function(
+            allocator,
+            view_queries.as_slice(),
+            fn_name,
+            Some(&mut job.pool),
+        ))
+    } else {
+        None
+    };
+
     let compiled = compile_template(&mut job);
 
     // Stage 6: Compile host bindings (if any)
     let host_binding_result = compile_component_host_bindings(allocator, metadata);
 
     // Stage 7: Generate ɵcmp/ɵfac definitions
+    // Pass the pre-pooled attrs_ref so the attrs entry uses the correct constant index
     let definitions = generate_component_definitions(
         allocator,
         metadata,
         &mut job,
         compiled.template_fn,
         host_binding_result,
+        attrs_ref,
+        view_query_fn,
     );
 
     // Emit JavaScript
@@ -809,6 +870,9 @@ fn compile_component_full<'a>(
         None
     };
 
+    // Get the next pool index for the next component in this file
+    let next_pool_index = job.pool.next_name_index();
+
     // Collect any diagnostics from the compilation job
     // (Done after using job to avoid borrow issues)
     diagnostics.extend(job.diagnostics);
@@ -818,7 +882,14 @@ fn compile_component_full<'a>(
         // Errors would have been caught earlier in parsing/transformation
     }
 
-    Ok(FullCompilationResult { template_js, cmp_js, fac_js, declarations_js, hmr_initializer_js })
+    Ok(FullCompilationResult {
+        template_js,
+        cmp_js,
+        fac_js,
+        declarations_js,
+        hmr_initializer_js,
+        next_pool_index,
+    })
 }
 
 /// Resolve template content from inline or external source.
@@ -1050,6 +1121,7 @@ pub fn compile_template_to_js_with_options<'a>(
         enable_debug_locations,
         template_source: Some(template),
         all_deferrable_deps_fn: None,
+        pool_starting_index: 0, // Standalone template compilation starts from 0
     };
 
     // Stage 3-5: Ingest and compile
@@ -1216,6 +1288,7 @@ pub fn compile_template_for_hmr<'a>(
         enable_debug_locations,
         template_source: Some(template),
         all_deferrable_deps_fn: None,
+        pool_starting_index: 0, // HMR template compilation starts from 0
     };
 
     // Stage 3-5: Ingest and compile
@@ -1546,6 +1619,56 @@ fn convert_host_metadata_input_to_host_metadata<'a>(
     }
 }
 
+/// Pool selector attrs constant BEFORE template compilation.
+///
+/// This matches TypeScript Angular's behavior where the attrs constant is added to
+/// the constant pool BEFORE template ingestion and compilation. By pooling it first,
+/// attrs gets the first available constant index (_c0), ensuring the correct constant
+/// ordering in the output.
+///
+/// See: packages/compiler/src/render3/view/compiler.ts lines 192-212
+fn pool_selector_attrs<'a>(
+    allocator: &'a Allocator,
+    job: &mut crate::pipeline::compilation::ComponentCompilationJob<'a>,
+    metadata: &super::metadata::ComponentMetadata<'a>,
+) -> Option<crate::output::ast::OutputExpression<'a>> {
+    use crate::output::ast::{LiteralArrayExpr, LiteralExpr, LiteralValue, OutputExpression};
+    use crate::pipeline::selector::CssSelector;
+    use oxc_allocator::FromIn;
+
+    let selector = metadata.selector.as_ref()?;
+    let parsed_selectors = CssSelector::parse(selector);
+    let first_selector = parsed_selectors.first()?;
+    let selector_attrs = first_selector.get_attrs();
+
+    if selector_attrs.is_empty() {
+        return None;
+    }
+
+    // Build the attrs array: ["attrName", "attrValue", ...]
+    let mut attr_entries: OxcVec<'a, OutputExpression<'a>> =
+        OxcVec::with_capacity_in(selector_attrs.len(), allocator);
+    for attr in selector_attrs {
+        attr_entries.push(OutputExpression::Literal(oxc_allocator::Box::new_in(
+            LiteralExpr {
+                value: LiteralValue::String(Atom::from_in(attr.as_str(), allocator)),
+                source_span: None,
+            },
+            allocator,
+        )));
+    }
+
+    // Create the attrs array literal
+    let attrs_array = OutputExpression::LiteralArray(oxc_allocator::Box::new_in(
+        LiteralArrayExpr { entries: attr_entries, source_span: None },
+        allocator,
+    ));
+
+    // Pool the attrs array using constantPool.getConstLiteral() with forceShared=true
+    // This extracts it to a const like: const _c0 = ["bitBadge", ""];
+    Some(job.pool.get_const_literal(attrs_array, true))
+}
+
 /// Compile host bindings from HostMetadataInput (owned strings).
 ///
 /// This is used by `compile_template_to_js_with_options` when host metadata is provided

crates/oxc_angular_compiler/src/directive/compiler.rs

@@ -98,10 +98,13 @@ fn build_base_directive_fields<'a>(
 
     // contentQueries: (rf, ctx, dirIndex) => { ... }
     if !metadata.queries.is_empty() {
+        // Note: Directive compiler doesn't have access to constant pool, so predicates
+        // are not pooled. For components, pool is passed from component compilation.
         let content_queries_fn = super::query::create_content_queries_function(
             allocator,
             &metadata.queries,
             Some(metadata.name.as_str()),
+            None,
         );
         entries.push(LiteralMapEntry {
             key: Atom::from("contentQueries"),
@@ -112,10 +115,13 @@ fn build_base_directive_fields<'a>(
 
     // viewQuery: (rf, ctx) => { ... }
     if !metadata.view_queries.is_empty() {
+        // Note: Directive compiler doesn't have access to constant pool, so predicates
+        // are not pooled. For components, pool is passed from component compilation.
         let view_queries_fn = super::query::create_view_queries_function(
             allocator,
             &metadata.view_queries,
             Some(metadata.name.as_str()),
+            None,
         );
         entries.push(LiteralMapEntry {
             key: Atom::from("viewQuery"),