fix(directive): reject @Input / @Output on signal inputs, models and outputs like ngtsc

`@Input() value = input(0)` compiled as a plain input with no error; ngtsc
reports "Using @input with a signal input is not allowed." oxc only looked at
the initializer of a member also listed in `inputs:` (for a different error),
and had no such check. The same went for `@Input` on `model()`, and `@Output`
on `output()`, `outputFromObservable()` or `model()`.

Each is now reported on the decorator with ngtsc's message, in its order: an
input's check comes before its `@Input` arguments are read, an output's after
its `@Output` arguments. The call counts only when it's Angular's API by its
import (any alias, a namespace, `.required`), so a local or foreign `input()`
is left alone. The compiled output is unchanged, as for other errors.

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

Author: Brooooooklyn

crates/oxc_angular_compiler/src/directive/decorator.rs

@@ -1055,6 +1055,20 @@ pub fn decorator_io_errors<'a>(
             // `@Input(...)`, as ngtsc's `tryParseInputFieldMapping` reads it.
             let decorator =
                 super::property_decorators::member_decorator(decorators, "Input", consts);
+            // ngtsc rejects `@Input` on a signal input or model before reading
+            // the decorator.
+            if let (Some(decorator), Some(value)) = (decorator, value) {
+                let message = if is_initializer_api_call(value, consts, &[INPUT_API]) {
+                    Some("Using @Input with a signal input is not allowed.")
+                } else if is_initializer_api_call(value, consts, &[MODEL_API]) {
+                    Some("Using @Input with a model input is not allowed.")
+                } else {
+                    None
+                };
+                if let Some(message) = message {
+                    return Some((message.to_string(), decorator.span));
+                }
+            }
             let error =
                 decorator.and_then(|d| input_decorator_error(d, &name, class, consts, &evaluator));
             if error.is_some() {
@@ -1075,17 +1089,32 @@ pub fn decorator_io_errors<'a>(
         class.body.body.iter().find_map(|element| {
             // `@Output(...)`, as ngtsc's `tryParseDecoratorOutput` reads it, on
             // the members an output is compiled from.
-            let decorators = match element {
-                ClassElement::PropertyDefinition(p) => Some(&p.decorators),
-                ClassElement::AccessorProperty(p) => Some(&p.decorators),
-                _ => None,
+            let (decorators, value) = match element {
+                ClassElement::PropertyDefinition(p) => (Some(&p.decorators), p.value.as_ref()),
+                ClassElement::AccessorProperty(p) => (Some(&p.decorators), p.value.as_ref()),
+                _ => (None, None),
             };
             let decorator = decorators.and_then(|decorators| {
                 super::property_decorators::member_decorator(decorators, "Output", consts)
             });
             if let Some(error) = decorator.and_then(|d| output_decorator_error(d, &evaluator)) {
                 return Some(error);
             }
+            // Then `@Output` on an `output()` or a model, like ngtsc's
+            // `parseOutputFields`.
+            if let (Some(decorator), Some(value)) = (decorator, value) {
+                let apis = [OUTPUT_API, OUTPUT_FROM_OBSERVABLE_API];
+                let message = if is_initializer_api_call(value, consts, &apis) {
+                    Some("Using \"@Output\" with \"output()\" is not allowed.")
+                } else if is_initializer_api_call(value, consts, &[MODEL_API]) {
+                    Some("Using @Output with a model input is not allowed.")
+                } else {
+                    None
+                };
+                if let Some(message) = message {
+                    return Some((message.to_string(), decorator.span));
+                }
+            }
             let ClassElement::PropertyDefinition(prop) = element else { return None };
             let (value, name) = (prop.value.as_ref()?, prop.key.static_name()?);
             if !meta_outputs.contains(&name.as_ref()) {

crates/oxc_angular_compiler/tests/decorator_metadata_ngtsc_test.rs

@@ -307,7 +307,7 @@ fn decorator_metadata_matches_ngtsc() {
         failures.len(),
         failures.join("\n\n")
     );
-    assert_eq!(compared, 859, "fixtures compared");
+    assert_eq!(compared, 902, "fixtures compared");
 }
 
 fn transform(source: &str) -> TransformResult {