align more

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/decorator.rs

@@ -0,0 +1,338 @@
+//! Directive definition generation (ɵdir and ɵfac).
+//!
+//! This module generates the Angular runtime definitions that are added
+//! as static properties on directive classes:
+//!
+//! - `ɵdir`: Directive definition created by `ɵɵdefineDirective()`
+//! - `ɵfac`: Factory function for instantiating the directive
+//!
+//! These definitions are used by Angular's runtime to:
+//! - Match the directive to elements via selector
+//! - Handle host bindings and listeners
+//! - Inject dependencies
+//! - Manage directive lifecycle
+
+use oxc_allocator::{Allocator, Vec};
+
+use super::compiler::compile_directive;
+use super::metadata::R3DirectiveMetadata;
+use crate::factory::{
+    FactoryTarget, R3ConstructorFactoryMetadata, R3DependencyMetadata, R3FactoryDeps,
+    R3FactoryMetadata, compile_factory_function,
+};
+use crate::output::ast::OutputExpression;
+
+/// Result of generating directive definitions.
+pub struct DirectiveDefinitions<'a> {
+    /// The ɵdir definition (directive metadata for Angular runtime).
+    pub dir_definition: OutputExpression<'a>,
+
+    /// The ɵfac factory function.
+    pub fac_definition: OutputExpression<'a>,
+}
+
+/// Generate ɵdir and ɵfac definitions for a directive.
+///
+/// # Arguments
+///
+/// * `allocator` - Memory allocator
+/// * `metadata` - Directive metadata extracted from decorator
+///
+/// # Returns
+///
+/// The ɵdir and ɵfac definitions as output expressions.
+///
+/// # Example Output
+///
+/// ```javascript
+/// // ɵdir definition:
+/// MyDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({
+///   type: MyDirective,
+///   selectors: [["", "myDir", ""]],
+///   inputs: { prop: "prop" },
+///   outputs: { click: "click" },
+///   hostBindings: function(rf, ctx) { ... },
+///   features: [i0.ɵɵNgOnChangesFeature]
+/// });
+///
+/// // ɵfac definition:
+/// MyDirective.ɵfac = function MyDirective_Factory(__ngFactoryType__) {
+///   return new (__ngFactoryType__ || MyDirective)(
+///     i0.ɵɵdirectiveInject(ServiceA),
+///     i0.ɵɵdirectiveInject(ServiceB, 8)  // 8 = Optional flag
+///   );
+/// };
+/// ```
+pub fn generate_directive_definitions<'a>(
+    allocator: &'a Allocator,
+    metadata: &R3DirectiveMetadata<'a>,
+) -> DirectiveDefinitions<'a> {
+    let dir_definition = generate_dir_definition(allocator, metadata);
+    let fac_definition = generate_fac_definition(allocator, metadata);
+
+    DirectiveDefinitions { dir_definition, fac_definition }
+}
+
+/// Generate the ɵdir definition.
+///
+/// This calls `compile_directive()` which creates an expression like:
+/// ```javascript
+/// /*@__PURE__*/ i0.ɵɵdefineDirective({
+///   type: MyDirective,
+///   selectors: [["", "myDir", ""]],
+///   inputs: { prop: "prop" },
+///   outputs: { click: "click" },
+///   hostBindings: function(rf, ctx) { ... },
+///   features: [i0.ɵɵNgOnChangesFeature]
+/// })
+/// ```
+fn generate_dir_definition<'a>(
+    allocator: &'a Allocator,
+    metadata: &R3DirectiveMetadata<'a>,
+) -> OutputExpression<'a> {
+    let result = compile_directive(allocator, metadata);
+    result.expression
+}
+
+/// Generate the ɵfac factory function.
+///
+/// Creates an expression like:
+/// ```javascript
+/// // Without dependencies:
+/// function DirectiveClass_Factory(__ngFactoryType__) {
+///   return new (__ngFactoryType__ || DirectiveClass)();
+/// }
+///
+/// // With dependencies:
+/// function DirectiveClass_Factory(__ngFactoryType__) {
+///   return new (__ngFactoryType__ || DirectiveClass)(
+///     i0.ɵɵdirectiveInject(ServiceA),
+///     i0.ɵɵdirectiveInject(ServiceB, 8)  // 8 = Optional flag
+///   );
+/// }
+/// ```
+///
+/// Ported from: `packages/compiler/src/render3/r3_factory.ts`
+fn generate_fac_definition<'a>(
+    allocator: &'a Allocator,
+    metadata: &R3DirectiveMetadata<'a>,
+) -> OutputExpression<'a> {
+    // Factory function name: DirectiveName_Factory
+    let factory_name = allocator.alloc_str(&format!("{}_Factory", metadata.name));
+
+    // Convert deps to R3FactoryDeps
+    let factory_deps = match &metadata.deps {
+        Some(deps) => {
+            // Clone deps into a new Vec for R3FactoryDeps
+            let mut factory_deps: Vec<'a, R3DependencyMetadata<'a>> =
+                Vec::with_capacity_in(deps.len(), allocator);
+            for dep in deps {
+                factory_deps.push(R3DependencyMetadata {
+                    token: dep.token.as_ref().map(|t| t.clone_in(allocator)),
+                    attribute_name_type: dep
+                        .attribute_name_type
+                        .as_ref()
+                        .map(|a| a.clone_in(allocator)),
+                    host: dep.host,
+                    optional: dep.optional,
+                    self_: dep.self_,
+                    skip_self: dep.skip_self,
+                });
+            }
+            R3FactoryDeps::Valid(factory_deps)
+        }
+        None => R3FactoryDeps::None,
+    };
+
+    // Create factory metadata
+    let factory_meta = R3FactoryMetadata::Constructor(R3ConstructorFactoryMetadata {
+        name: metadata.name,
+        type_expr: metadata.r#type.clone_in(allocator),
+        type_decl: metadata.r#type.clone_in(allocator),
+        type_argument_count: metadata.type_argument_count,
+        deps: factory_deps,
+        target: FactoryTarget::Directive,
+    });
+
+    // Compile the factory function
+    let result = compile_factory_function(allocator, &factory_meta, factory_name);
+    result.expression
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::directive::metadata::R3HostMetadata;
+    use crate::output::ast::ReadVarExpr;
+    use crate::output::emitter::JsEmitter;
+    use oxc_allocator::Box;
+    use oxc_span::Atom;
+
+    fn create_test_metadata<'a>(allocator: &'a Allocator) -> R3DirectiveMetadata<'a> {
+        let type_expr = OutputExpression::ReadVar(Box::new_in(
+            ReadVarExpr { name: Atom::from("TestDirective"), source_span: None },
+            allocator,
+        ));
+
+        R3DirectiveMetadata {
+            name: Atom::from("TestDirective"),
+            r#type: type_expr,
+            type_argument_count: 0,
+            deps: None,
+            selector: Some(Atom::from("[testDir]")),
+            queries: Vec::new_in(allocator),
+            view_queries: Vec::new_in(allocator),
+            host: R3HostMetadata::new(allocator),
+            uses_on_changes: false,
+            inputs: Vec::new_in(allocator),
+            outputs: Vec::new_in(allocator),
+            uses_inheritance: false,
+            export_as: Vec::new_in(allocator),
+            providers: None,
+            is_standalone: true,
+            is_signal: false,
+            host_directives: Vec::new_in(allocator),
+        }
+    }
+
+    #[test]
+    fn test_generate_directive_definitions() {
+        let allocator = Allocator::default();
+        let metadata = create_test_metadata(&allocator);
+
+        let definitions = generate_directive_definitions(&allocator, &metadata);
+
+        let emitter = JsEmitter::new();
+
+        // Check dir definition
+        let dir_js = emitter.emit_expression(&definitions.dir_definition);
+        assert!(dir_js.contains("defineDirective"));
+        assert!(dir_js.contains("TestDirective"));
+        assert!(dir_js.contains("selectors"));
+
+        // Check fac definition
+        let fac_js = emitter.emit_expression(&definitions.fac_definition);
+        assert!(fac_js.contains("TestDirective_Factory"));
+        assert!(fac_js.contains("__ngFactoryType__"));
+    }
+
+    #[test]
+    fn test_generate_fac_definition_without_deps() {
+        let allocator = Allocator::default();
+        let metadata = create_test_metadata(&allocator);
+
+        let fac = generate_fac_definition(&allocator, &metadata);
+
+        let emitter = JsEmitter::new();
+        let js = emitter.emit_expression(&fac);
+
+        // Should have inherited factory pattern (IIFE with getInheritedFactory)
+        // because deps is None
+        assert!(js.contains("getInheritedFactory") || js.contains("ɵɵgetInheritedFactory"));
+        assert!(js.contains("TestDirective"));
+    }
+
+    #[test]
+    fn test_generate_fac_definition_with_empty_deps() {
+        let allocator = Allocator::default();
+        let type_expr = OutputExpression::ReadVar(Box::new_in(
+            ReadVarExpr { name: Atom::from("TestDirective"), source_span: None },
+            &allocator,
+        ));
+
+        let metadata = R3DirectiveMetadata {
+            name: Atom::from("TestDirective"),
+            r#type: type_expr,
+            type_argument_count: 0,
+            deps: Some(Vec::new_in(&allocator)), // Empty deps - has constructor but no params
+            selector: Some(Atom::from("[testDir]")),
+            queries: Vec::new_in(&allocator),
+            view_queries: Vec::new_in(&allocator),
+            host: R3HostMetadata::new(&allocator),
+            uses_on_changes: false,
+            inputs: Vec::new_in(&allocator),
+            outputs: Vec::new_in(&allocator),
+            uses_inheritance: false,
+            export_as: Vec::new_in(&allocator),
+            providers: None,
+            is_standalone: true,
+            is_signal: false,
+            host_directives: Vec::new_in(&allocator),
+        };
+
+        let fac = generate_fac_definition(&allocator, &metadata);
+
+        let emitter = JsEmitter::new();
+        let js = emitter.emit_expression(&fac);
+
+        // Should have simple factory (no inherited factory pattern)
+        assert!(js.contains("TestDirective_Factory"));
+        assert!(js.contains("__ngFactoryType__"));
+        assert!(js.contains("new"));
+        // Should NOT have getInheritedFactory
+        assert!(!js.contains("getInheritedFactory"));
+    }
+
+    #[test]
+    fn test_generate_fac_definition_with_deps() {
+        let allocator = Allocator::default();
+        let type_expr = OutputExpression::ReadVar(Box::new_in(
+            ReadVarExpr { name: Atom::from("TestDirective"), source_span: None },
+            &allocator,
+        ));
+
+        let dep_token = OutputExpression::ReadVar(Box::new_in(
+            ReadVarExpr { name: Atom::from("SomeService"), source_span: None },
+            &allocator,
+        ));
+
+        let mut deps = Vec::new_in(&allocator);
+        deps.push(crate::factory::R3DependencyMetadata::simple(dep_token));
+
+        let metadata = R3DirectiveMetadata {
+            name: Atom::from("TestDirective"),
+            r#type: type_expr,
+            type_argument_count: 0,
+            deps: Some(deps),
+            selector: Some(Atom::from("[testDir]")),
+            queries: Vec::new_in(&allocator),
+            view_queries: Vec::new_in(&allocator),
+            host: R3HostMetadata::new(&allocator),
+            uses_on_changes: false,
+            inputs: Vec::new_in(&allocator),
+            outputs: Vec::new_in(&allocator),
+            uses_inheritance: false,
+            export_as: Vec::new_in(&allocator),
+            providers: None,
+            is_standalone: true,
+            is_signal: false,
+            host_directives: Vec::new_in(&allocator),
+        };
+
+        let fac = generate_fac_definition(&allocator, &metadata);
+
+        let emitter = JsEmitter::new();
+        let js = emitter.emit_expression(&fac);
+
+        // Should have directiveInject call (not just inject)
+        assert!(js.contains("directiveInject"));
+        assert!(js.contains("SomeService"));
+    }
+
+    #[test]
+    fn test_generate_dir_definition() {
+        let allocator = Allocator::default();
+        let metadata = create_test_metadata(&allocator);
+
+        let dir = generate_dir_definition(&allocator, &metadata);
+
+        let emitter = JsEmitter::new();
+        let js = emitter.emit_expression(&dir);
+
+        assert!(js.contains("ɵɵdefineDirective"));
+        assert!(js.contains("type"));
+        assert!(js.contains("TestDirective"));
+        assert!(js.contains("selectors"));
+        assert!(js.contains("testDir"));
+    }
+}

crates/oxc_angular_compiler/src/component/transform.rs

@@ -13,11 +13,15 @@
 //! - Lifecycle hooks
 
 mod compiler;
+mod decorator;
+mod definition;
 mod metadata;
 mod property_decorators;
 mod query;
 
 pub use compiler::{DirectiveCompileResult, compile_directive, compile_directive_from_metadata};
+pub use decorator::{extract_directive_metadata, find_directive_decorator_span};
+pub use definition::{DirectiveDefinitions, generate_directive_definitions};
 pub use metadata::{
     QueryPredicate, R3DirectiveMetadata, R3DirectiveMetadataBuilder, R3HostDirectiveMetadata,
     R3HostMetadata, R3InputMetadata, R3QueryMetadata,