fix(directive): compile inputs:/outputs: declared in decorator metadata

[ashley-hunter]

Stack (1/5): #493 inputs/outputs → #494 transform validation → #495 queries: → #496 .d.ts transform types → #504 signal API import identity. This is #493.

Fixes inputs: and outputs: declared in @Directive / @Component metadata being silently dropped from the compiled definition.

The bug

@Directive({
  selector: 'a',
  inputs: ['x', { name: 'y', alias: 'why', transform: bool }],
})
class A { x?: string; y?: boolean; }

compiled to ɵɵdefineDirective({ type: A, selectors: [["a"]] }): no inputs at all. The decorator parsers never read the inputs/outputs keys, so there was no error either, and a binding like [x]="..." went to the element as a property instead of reaching the directive. The same happened for @Component, for outputs:, and on abstract @Directive() bases (whose subclasses then inherited nothing).

The fix

Both decorator parsers now read inputs: ('name', 'name: alias', { name, alias?, required?, transform? }) and outputs: ('name', 'name: alias') and merge them with @Input/@Output/signal members the way ngtsc does ({...inputsFromMeta, ...inputsFromFields}): keyed by class property, a member replacing a metadata entry in place, a repeated metadata entry keeping its first position, and anything after a second : ignored. Keys follow JS object rules, as in ngtsc's object: a __proto__ entry is dropped and integer-like keys come first.

Values are read through directive/evaluator.rs, a single-file model of ngtsc's partial evaluator. It resolves what ngtsc resolves within one file:

• literals, arrays and objects with spreads, template literals (also with numbers and enum members)
• same-file const/let/var (the first var wins), destructuring (const {a} = ..., const [a] = ...), enums, and declare const X: ['a']
• binary, unary, conditional and &&/|| operators
• calls to same-file functions and static methods whose body is a single return. A transform returned from such a helper (inputs: make('x', booleanAttribute)) is emitted as the expression passed at the call site, so it stays in scope
• array.concat/slice/length and string.concat

Syntax ngtsc doesn't evaluate is rejected too: satisfies, <T>x, ??, numeric computed keys, array['0'], string.length, computed decorator keys ([K]: [...]). Each file's top-level declarations are only collected when a decorator needs one, each const is evaluated once and dependencies-first (so long chains don't nest), and a depth and work limit stop cycles, recursion and exponential growth.

Forms ngtsc rejects now report its diagnostic word for word, at the node ngtsc points to (the inputs:/outputs: value, or the colliding member), instead of being dropped: a non-array inputs:/outputs:, entries that aren't strings or object literals, objects without a string name, and a signal input()/output()/model() also listed in the metadata. That check, like ngtsc's, only counts Angular's own functions: a named import (aliases too) or a namespace import from @angular/core, and outputFromObservable from @angular/core/rxjs-interop. A same-named local or foreign function doesn't collide. The value descriptions match too (a bad spread marks only its element, enum members are of type 'E', let x; is undefined, unknown names could not be determined statically). Like ngtsc, only the first error per class is reported.

One deliberate difference: ngtsc follows imports, but OXC compiles one file at a time. A value imported from another module (including an imported alias or required, which would otherwise change the binding) reports:

@Directive.inputs depends on 'SHARED', which is imported from another module. OXC compiles one file at a time and cannot evaluate values from other files.

Two more differences, both where ngtsc emits code that doesn't work:

• A transform that uses its helper's parameters in any other way ((v) => v + name, with name a helper parameter) is an error. ngtsc copies it, and name then refers to a global.
• An import passed inside an object argument (make({t: booleanAttribute}), returning o.t) is an error. ngtsc emits booleanAttribute.

(A small output-only difference is recorded in the snapshot: oxc quotes integer-like keys in the JS inputs map, where ngtsc leaves them bare. The order is the same.)

A transform returned by a helper is checked with JavaScript scoping: names the transform declares itself (parameters, const, functions, classes, loop and catch bindings, hoisted vars) hide the helper's parameters, and a nested normal function has its own this / arguments. Arguments passed through spreads (make(...args)) or read through rest parameters (a[1]) keep where they were written, so they emit like ngtsc.

&& / || need an imported operand only when it is the left one or the one picked (LOCAL || NAME is LOCAL), and c ? a : b evaluates only the branch it picks, like ngtsc. When the import decides the result, the "imported from another module" error is kept.

The scope check for a helper's transform ignores types (annotations, return types, type arguments and parameters, the type part of as / satisfies / <T>, local type aliases and interfaces), since they're erased; ngtsc accepts these. A helper parameter used at runtime next to a type (name!, name as T, a default value) is still reported.

Values exported from a same-file namespace are evaluated through typeof NS.X and aliases like import I = NS.X, scoped and merged like TypeScript. As in ngtsc, NS.X in a value position stays dynamic, and a transform written in a namespace that uses the namespace's own declarations is reported.

Tests

• decorator_inputs_outputs_test.rs: the original report, which failed before the fix.
• decorator_metadata_ngtsc_test.rs compares diagnostics, diagnostic spans, the inputs/outputs maps and the .d.ts declarations with a snapshot of @angular/compiler-cli 22.1.7's output (tests/fixtures/decorator_metadata_ngtsc.json, 229 cases). 14 are Angular's own specs for decorator inputs/outputs (ngtsc_spec, authoring_{inputs,outputs,models}_spec, the order_bindings compliance case), the rest probe the evaluator and its diagnostics. Maps are compared ignoring whitespace and parentheses (which the two emitters place differently) outside string literals, so a stray space inside an emitted name still fails.
• Separate tests cover the imported-value message and that long chains, cycles and exponential inputs don't overflow the stack or hang.
• The Angular specs, plus the directive_spec / inherit_definition_feature_spec acceptance cases, are also added to the compare harness (decorator-metadata-angular-spec.fixture.ts), which diffs the full file against a live ngtsc.