Angular compare tool: Major polish and full semantics improvements

## Rust Compiler Improvements
- Add hostDirectives parsing to component decorator extraction
- Wire @HostBinding/@HostListener extraction to component metadata
- Fix key format: wrap with []/() for proper classification
- Fix @HostListener args preservation (e.g., handleClick($event))
- Fix HTML lexer escapable raw text entity handling

## Compare Tool Enhancements
- Add full-file transformation support (transformAngularFile API)
- Add const value normalization for fair comparison
- Improve template function extraction (AST-based, handles const/arrow)
- Replace Set-based diff with LCS algorithm (preserves ordering)
- Add version metadata to reports (oxcVersion, angularVersion)

## Metadata Pass-through Fixes
- Fix host keys double-wrapping issue
- Pass providers, viewProviders, animations, schemas, styles, exportAs
- Make preserveWhitespaces and i18nUseExternalIds configurable
- Fix hostDirectives forward-ref flag pass-through

## Test Infrastructure
- Add new fixture categories: full-transform, host-directives, schemas, etc.
- Fix decorator detection (@angular/core instead of @component string)
- Add comprehensive test coverage for host decorators

Results: 92.4% material-angular match rate (587/635), 92.8% fixtures

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/decorator.rs

@@ -26,8 +26,8 @@ pub use metadata::{
     TemplateDependencyKind, ViewEncapsulation,
 };
 pub use transform::{
-    CompiledComponent, HmrTemplateCompileOutput, ResolvedResources, TemplateCompileOutput,
-    TransformOptions, TransformResult, compile_component_template, compile_for_hmr,
-    compile_template_for_hmr, compile_template_to_js, compile_template_to_js_with_options,
-    transform_angular_file,
+    CompiledComponent, HmrTemplateCompileOutput, HostMetadataInput, ResolvedResources,
+    TemplateCompileOutput, TransformOptions, TransformResult, compile_component_template,
+    compile_for_hmr, compile_template_for_hmr, compile_template_to_js,
+    compile_template_to_js_with_options, transform_angular_file,
 };

crates/oxc_angular_compiler/src/component/mod.rs

@@ -92,6 +92,30 @@ pub struct TransformOptions {
 
     /// Override the preserve whitespaces setting.
     pub preserve_whitespaces: Option<bool>,
+
+    /// Host bindings metadata for the component.
+    /// Contains property bindings, attribute bindings, and event listeners.
+    pub host: Option<HostMetadataInput>,
+}
+
+/// Input for host metadata when passed via TransformOptions.
+/// Uses owned String types for easier NAPI interop.
+#[derive(Debug, Clone, Default)]
+pub struct HostMetadataInput {
+    /// Host property bindings: `{ "[class.active]": "isActive" }`
+    pub properties: Vec<(String, String)>,
+
+    /// Host attribute bindings: `{ "role": "button" }`
+    pub attributes: Vec<(String, String)>,
+
+    /// Host event listeners: `{ "(click)": "onClick()" }`
+    pub listeners: Vec<(String, String)>,
+
+    /// Special attribute for static class binding.
+    pub class_attr: Option<String>,
+
+    /// Special attribute for static style binding.
+    pub style_attr: Option<String>,
 }
 
 impl Default for TransformOptions {
@@ -110,6 +134,7 @@ impl Default for TransformOptions {
             encapsulation: None,
             change_detection: None,
             preserve_whitespaces: None,
+            host: None,
         }
     }
 }
@@ -931,6 +956,34 @@ pub fn compile_template_to_js_with_options<'a>(
         all_statements.push(main_fn_stmt);
     }
 
+    // Stage 6: Compile host bindings if provided via options
+    if let Some(ref host_input) = options.host {
+        if let Some(host_result) = compile_host_bindings_from_input(
+            allocator,
+            host_input,
+            component_name,
+            options.selector.as_deref(),
+        ) {
+            // Add the host bindings function as a declaration if present
+            if let Some(host_fn) = host_result.host_binding_fn {
+                if let Some(fn_name) = host_fn.name.clone() {
+                    let host_fn_stmt =
+                        OutputStatement::DeclareFunction(oxc_allocator::Box::new_in(
+                            DeclareFunctionStmt {
+                                name: fn_name,
+                                params: host_fn.params,
+                                statements: host_fn.statements,
+                                modifiers: StmtModifier::NONE,
+                                source_span: host_fn.source_span,
+                            },
+                            allocator,
+                        ));
+                    all_statements.push(host_fn_stmt);
+                }
+            }
+        }
+    }
+
     // Generate code with optional source map
     if options.sourcemap {
         let source_file = Arc::new(ParseSourceFile::new(template, file_path));
@@ -1285,6 +1338,80 @@ fn parse_event_target(event_name: &str) -> (&str, Option<&str>) {
     }
 }
 
+/// Convert HostMetadataInput (owned strings) to HostMetadata<'a> (with Atom types).
+///
+/// This function is used when compiling templates in isolation (e.g., for the compare tool)
+/// where the host metadata comes from NAPI options rather than from parsing a decorator.
+fn convert_host_metadata_input_to_host_metadata<'a>(
+    allocator: &'a Allocator,
+    input: &HostMetadataInput,
+) -> HostMetadata<'a> {
+    use oxc_allocator::FromIn;
+
+    let mut properties: OxcVec<'a, (Atom<'a>, Atom<'a>)> = OxcVec::new_in(allocator);
+    for (k, v) in &input.properties {
+        properties
+            .push((Atom::from_in(k.as_str(), allocator), Atom::from_in(v.as_str(), allocator)));
+    }
+
+    let mut attributes: OxcVec<'a, (Atom<'a>, Atom<'a>)> = OxcVec::new_in(allocator);
+    for (k, v) in &input.attributes {
+        attributes
+            .push((Atom::from_in(k.as_str(), allocator), Atom::from_in(v.as_str(), allocator)));
+    }
+
+    let mut listeners: OxcVec<'a, (Atom<'a>, Atom<'a>)> = OxcVec::new_in(allocator);
+    for (k, v) in &input.listeners {
+        listeners
+            .push((Atom::from_in(k.as_str(), allocator), Atom::from_in(v.as_str(), allocator)));
+    }
+
+    HostMetadata {
+        properties,
+        attributes,
+        listeners,
+        class_attr: input.class_attr.as_ref().map(|s| Atom::from_in(s.as_str(), allocator)),
+        style_attr: input.style_attr.as_ref().map(|s| Atom::from_in(s.as_str(), allocator)),
+    }
+}
+
+/// Compile host bindings from HostMetadataInput (owned strings).
+///
+/// This is used by `compile_template_to_js_with_options` when host metadata is provided
+/// via TransformOptions for isolated template compilation.
+fn compile_host_bindings_from_input<'a>(
+    allocator: &'a Allocator,
+    host_input: &HostMetadataInput,
+    component_name: &str,
+    selector: Option<&str>,
+) -> Option<HostBindingCompilationResult<'a>> {
+    use oxc_allocator::FromIn;
+
+    // Check if there are any host bindings at all
+    if host_input.properties.is_empty()
+        && host_input.attributes.is_empty()
+        && host_input.listeners.is_empty()
+    {
+        return None;
+    }
+
+    // Convert to HostMetadata
+    let host = convert_host_metadata_input_to_host_metadata(allocator, host_input);
+
+    // Get component name and selector as atoms
+    let component_name_atom = Atom::from_in(component_name, allocator);
+    let component_selector =
+        selector.map(|s| Atom::from_in(s, allocator)).unwrap_or_else(|| Atom::from(""));
+
+    // Convert to HostBindingInput and compile
+    let input =
+        convert_host_metadata_to_input(allocator, &host, component_name_atom, component_selector);
+    let mut job = ingest_host_binding(allocator, input);
+    let result = compile_host_bindings(&mut job);
+
+    Some(result)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/oxc_angular_compiler/src/component/transform.rs

@@ -436,17 +436,34 @@ impl<'a> R3DirectiveMetadataBuilder<'a> {
         }
 
         // Extract host bindings from @HostBinding
+        // Wrap with brackets: "class.active" -> "[class.active]"
         let host_bindings = super::property_decorators::extract_host_bindings(allocator, class);
         for (host_prop, class_prop) in host_bindings {
-            // Add to host.properties
-            self.host.properties.push((host_prop, class_prop));
+            // Add to host.properties with wrapped key
+            let wrapped_key = Atom::from(allocator.alloc_str(&format!("[{}]", host_prop.as_str())));
+            self.host.properties.push((wrapped_key, class_prop));
         }
 
         // Extract host listeners from @HostListener
+        // Wrap event name with parentheses and build method expression with args
+        // Reference: Angular's shared.ts:713 - `bindings.listeners[eventName] = \`${member.name}(${args.join(',')})\``
         let host_listeners = super::property_decorators::extract_host_listeners(allocator, class);
-        for (event_name, method_name, _args) in host_listeners {
+        for (event_name, method_name, args) in host_listeners {
+            // Wrap event name: "click" -> "(click)"
+            let wrapped_key =
+                Atom::from(allocator.alloc_str(&format!("({})", event_name.as_str())));
+
+            // Build method expression with args: "handleClick" + ["$event"] -> "handleClick($event)"
+            let method_expr = if args.is_empty() {
+                Atom::from(allocator.alloc_str(&format!("{}()", method_name.as_str())))
+            } else {
+                let args_str: String =
+                    args.iter().map(|a| a.as_str()).collect::<std::vec::Vec<_>>().join(",");
+                Atom::from(allocator.alloc_str(&format!("{}({})", method_name.as_str(), args_str)))
+            };
+
             // Add to host.listeners
-            self.host.listeners.push((event_name, method_name));
+            self.host.listeners.push((wrapped_key, method_expr));
         }
 
         self
@@ -723,11 +740,11 @@ mod tests {
         let metadata = metadata.unwrap();
         assert_eq!(metadata.host.properties.len(), 2);
 
-        // Check host bindings
-        assert_eq!(metadata.host.properties[0].0.as_str(), "class.active");
+        // Check host bindings - keys are wrapped with brackets
+        assert_eq!(metadata.host.properties[0].0.as_str(), "[class.active]");
         assert_eq!(metadata.host.properties[0].1.as_str(), "isActive");
 
-        assert_eq!(metadata.host.properties[1].0.as_str(), "attr.role");
+        assert_eq!(metadata.host.properties[1].0.as_str(), "[attr.role]");
         assert_eq!(metadata.host.properties[1].1.as_str(), "role");
     }
 
@@ -758,12 +775,12 @@ mod tests {
         let metadata = metadata.unwrap();
         assert_eq!(metadata.host.listeners.len(), 2);
 
-        // Check host listeners
-        assert_eq!(metadata.host.listeners[0].0.as_str(), "click");
-        assert_eq!(metadata.host.listeners[0].1.as_str(), "onClick");
+        // Check host listeners - keys are wrapped with parentheses, method expressions include ()
+        assert_eq!(metadata.host.listeners[0].0.as_str(), "(click)");
+        assert_eq!(metadata.host.listeners[0].1.as_str(), "onClick()");
 
-        assert_eq!(metadata.host.listeners[1].0.as_str(), "mouseenter");
-        assert_eq!(metadata.host.listeners[1].1.as_str(), "onMouseEnter");
+        assert_eq!(metadata.host.listeners[1].0.as_str(), "(mouseenter)");
+        assert_eq!(metadata.host.listeners[1].1.as_str(), "onMouseEnter()");
     }
 
     #[test]