refactor(compiler): add support for @input transforms under isolatedDeclarations

Adds support for `@Input` transform functions in isolated declarations mode (`emitDeclarationOnly: true`), allowing components and directives to specify `transform` functions without triggering fatal compiler errors.

Synthesizes the `ngAcceptInputType_` write type syntactically:
- For referenced functions (`transform: booleanAttribute`), emits `Parameters<typeof booleanAttribute>[0]`, relying on downstream template type checking to resolve the type.
- For inline functions (`transform: (v: string) => boolean`), extracts `parameters[0].type` directly from the local TypeScript AST.

Author: alxhub

packages/compiler-cli/src/ngtsc/annotations/common/src/input_transforms.ts

@@ -9,6 +9,7 @@
 import {ClassPropertyMapping, outputAst} from '@angular/compiler';
 
 import {InputMapping} from '../../../metadata';
+import {Reference} from '../../../imports';
 import {CompileResult} from '../../../transform';
 
 /** Generates additional fields to be added to a class that has inputs with transform functions. */
@@ -20,11 +21,12 @@ export function compileInputTransformFields(
   for (const input of inputs) {
     // Note: Signal inputs capture their transform `WriteT` as part of the `InputSignal`.
     // Such inputs will not have a `transform` captured and not generate coercion members.
-
     if (input.transform) {
       extraFields.push({
         name: `ngAcceptInputType_${input.classPropertyName}`,
-        type: outputAst.transplantedType(input.transform.type),
+        type: input.transform.type.synthetic
+          ? new outputAst.ExpressionType(new outputAst.WrappedNodeExpr(input.transform.type.node))
+          : outputAst.transplantedType(input.transform.type),
         statements: [],
         initializer: null,
         deferrableImports: null,

packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.ts

@@ -12,6 +12,7 @@ import {
   createMayBeForwardRefExpression,
   emitDistinctChangesOnlyDefaultValue,
   Expression,
+  ExpressionType,
   ExternalExpr,
   ExternalReference,
   ForwardRefHandling,
@@ -1502,20 +1503,68 @@ export function parseDecoratorInputTransformFunction(
   emitDeclarationOnly: boolean,
 ): DecoratorInputTransform {
   if (emitDeclarationOnly) {
-    const chain: ts.DiagnosticMessageChain = {
-      messageText:
-        '@Input decorators with a transform function are not supported in experimental declaration-only emission mode',
-      category: ts.DiagnosticCategory.Error,
-      code: 0,
-      next: [
-        {
-          messageText: `Consider converting '${clazz.name.text}.${classPropertyName}' to an input signal`,
-          category: ts.DiagnosticCategory.Message,
-          code: 0,
-        },
-      ],
-    };
-    throw new FatalDiagnosticError(ErrorCode.DECORATOR_UNEXPECTED, value.node, chain);
+    if (ts.isArrowFunction(value.node) || ts.isFunctionExpression(value.node)) {
+      const firstParam =
+        value.node.parameters[0]?.name?.getText() === 'this'
+          ? value.node.parameters[1]
+          : value.node.parameters[0];
+
+      if (!firstParam) {
+        const ref = new Reference(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword));
+        ref.synthetic = true;
+        return {
+          node: value.node,
+          type: ref,
+        };
+      }
+
+      if (!firstParam.type) {
+        throw createValueHasWrongTypeError(
+          value.node,
+          value,
+          'Input transform function first parameter must have a type',
+        );
+      }
+
+      if (firstParam.dotDotDotToken) {
+        throw createValueHasWrongTypeError(
+          value.node,
+          value,
+          'Input transform function first parameter cannot be a spread parameter',
+        );
+      }
+
+      const ref = new Reference(firstParam.type);
+      ref.synthetic = true;
+      return {
+        node: value.node,
+        type: ref,
+      };
+    }
+
+    const node =
+      value instanceof Reference ? value.getIdentityIn(clazz.getSourceFile()) : value.node;
+    const entityName = node ? expressionToEntityName(node as ts.Expression) : null;
+    if (entityName !== null) {
+      const typeQuery = ts.factory.createTypeQueryNode(entityName);
+      const parametersType = ts.factory.createTypeReferenceNode('Parameters', [typeQuery]);
+      const indexedAccess = ts.factory.createIndexedAccessTypeNode(
+        parametersType,
+        ts.factory.createLiteralTypeNode(ts.factory.createNumericLiteral('0')),
+      );
+      const ref = new Reference(indexedAccess);
+      ref.synthetic = true;
+      return {
+        node: value.node,
+        type: ref,
+      };
+    }
+
+    throw createValueHasWrongTypeError(
+      value.node,
+      value,
+      'Input transform function could not be referenced',
+    );
   }
   // In local compilation mode we can skip type checking the function args. This is because usually
   // the type check is done in a separate build which runs in full compilation mode. So here we skip
@@ -2208,3 +2257,14 @@ export function extractHostBindingResources(nodes: HostBindingNodes): ReadonlySe
 
   return result;
 }
+
+function expressionToEntityName(expr: ts.Expression): ts.EntityName | null {
+  if (ts.isIdentifier(expr)) {
+    return expr;
+  }
+  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name)) {
+    const left = expressionToEntityName(expr.expression);
+    return left === null ? null : ts.factory.createQualifiedName(left, expr.name);
+  }
+  return null;
+}

packages/compiler-cli/test/compliance/test_cases/r3_view_compiler_directives/host_directives/TEST_CASES.json

@@ -15,12 +15,7 @@
           ]
         }
       ],
-      "compilationModeFilter": [
-        "full compile",
-        "linked compile",
-        "local compile",
-        "declaration-only emit"
-      ]
+      "compilationModeFilter": ["full compile", "linked compile", "declaration-only emit"]
     },
     {
       "description": "should create hostDirective definitions for a chain of host directives",
@@ -36,12 +31,7 @@
           ]
         }
       ],
-      "compilationModeFilter": [
-        "full compile",
-        "linked compile",
-        "local compile",
-        "declaration-only emit"
-      ]
+      "compilationModeFilter": ["full compile", "linked compile", "declaration-only emit"]
     },
     {
       "description": "should handle a forwardRef used in hostDirectives",
@@ -57,12 +47,7 @@
           ]
         }
       ],
-      "compilationModeFilter": [
-        "full compile",
-        "linked compile",
-        "local compile",
-        "declaration-only emit"
-      ]
+      "compilationModeFilter": ["full compile", "linked compile", "declaration-only emit"]
     },
     {
       "description": "should handle the `inputs` and `outputs` options in host directives",
@@ -78,12 +63,7 @@
           ]
         }
       ],
-      "compilationModeFilter": [
-        "full compile",
-        "linked compile",
-        "local compile",
-        "declaration-only emit"
-      ]
+      "compilationModeFilter": ["full compile", "linked compile", "declaration-only emit"]
     },
     {
       "description": "should handle aliases to aliased `inputs` and `outputs` of a host directive",
@@ -99,12 +79,7 @@
           ]
         }
       ],
-      "compilationModeFilter": [
-        "full compile",
-        "linked compile",
-        "local compile",
-        "declaration-only emit"
-      ]
+      "compilationModeFilter": ["full compile", "linked compile", "declaration-only emit"]
     }
   ]
 }

packages/compiler-cli/test/ngtsc/declaration_only_emission_spec.ts

@@ -827,7 +827,7 @@ runInEachFileSystem(() => {
       );
     });
 
-    it('should show correct error message when using an @Input decorator with a transform function', () => {
+    it('should emit type declarations when using an @Input decorator with a transform function', () => {
       env.write(
         'test.ts',
         `
@@ -840,16 +840,52 @@ runInEachFileSystem(() => {
         `,
       );
 
+      env.driveMain();
+      const dtsContent = env.getContents('test.d.ts');
+
+      expect(dtsContent).toContain(
+        'static ngAcceptInputType_decoratedInput: Parameters<typeof i0.booleanAttribute>[0];',
+      );
+    });
+
+    it('should emit type declarations when using an @Input decorator with an inline transform function', () => {
+      env.write(
+        'test.ts',
+        `
+        import {Component, Input} from '@angular/core';
+
+        @Component({template: '', selector: 'comp'})
+        export class Comp {
+          @Input({ transform: (v: string) => !!v }) decoratedInput!: boolean;
+        }
+        `,
+      );
+
+      env.driveMain();
+      const dtsContent = env.getContents('test.d.ts');
+
+      expect(dtsContent).toContain('static ngAcceptInputType_decoratedInput: string;');
+    });
+
+    it('should produce a diagnostic when using an @Input decorator with an inline transform function missing a parameter type', () => {
+      env.write(
+        'test.ts',
+        `
+        import {Component, Input} from '@angular/core';
+
+        @Component({template: '', selector: 'comp'})
+        export class Comp {
+          @Input({ transform: (v) => !!v }) decoratedInput!: boolean;
+        }
+        `,
+      );
+
       const errors = env.driveDiagnostics();
 
       expect(errors.length).toBe(1);
-      expect(errors[0].code).toBe(ngErrorCode(ErrorCode.DECORATOR_UNEXPECTED));
-      const errorMessage = ts.flattenDiagnosticMessageText(errors[0].messageText, '\n');
-      expect(errorMessage).toContain(
-        '@Input decorators with a transform function are not supported in experimental declaration-only emission mode',
-      );
-      expect(errorMessage).toContain(
-        `Consider converting 'Comp.decoratedInput' to an input signal`,
+      expect(errors[0].code).toBe(ngErrorCode(ErrorCode.VALUE_HAS_WRONG_TYPE));
+      expect(ts.flattenDiagnosticMessageText(errors[0].messageText, '\n')).toContain(
+        'Input transform function first parameter must have a type',
       );
     });