refactor(compiler-cli): detect input functions without partial evaluation (angular#53872)

This allows us to ensure signal inputs and a potential JIT transform
remain single file compilation compatible. The consequences are that
options need to be statically analyzable more strictly, compared to
loosened restrictions with static interpretation where e.g. `alias`
can be defined through a shared variable.

PR Close angular#53872

Author: devversion

packages/compiler-cli/private/tooling.ts

@@ -61,8 +61,7 @@ export function angularJitApplicationTransform(
       typeChecker, reflectionHost, [], isCore,
       /* enableClosureCompiler */ false);
 
-  const inputSignalMetadataTransform =
-      getInputSignalsMetadataTransform(reflectionHost, evaluator, isCore);
+  const inputSignalMetadataTransform = getInputSignalsMetadataTransform(reflectionHost, isCore);
 
   return (ctx) => {
     return (sourceFile) => {

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

@@ -8,9 +8,9 @@
 
 import ts from 'typescript';
 
+import {ErrorCode, FatalDiagnosticError} from '../../../diagnostics';
 import {InputMapping} from '../../../metadata';
-import {PartialEvaluator} from '../../../partial_evaluator';
-import {ClassMember, ReflectionHost} from '../../../reflection';
+import {ClassMember, ReflectionHost, reflectObjectLiteral} from '../../../reflection';
 
 /** Metadata describing an input declared via the `input` function. */
 interface InputMemberMetadata {
@@ -45,8 +45,7 @@ function tryParseInputInitializerAndOptions(
   }
 
   // Case 1: No `required`.
-  // TODO(signal-input-public): Clean this up.
-  if (target.text === 'input' || target.text === 'ɵinput') {
+  if (target.text === 'input') {
     if (!isReferenceToInputFunction(target, coreModule, reflector)) {
       return null;
     }
@@ -108,8 +107,32 @@ function isReferenceToInputFunction(
     targetImport = {name: target.text};
   }
 
-  // TODO(signal-input-public): Clean this up.
-  return targetImport.name === 'input' || targetImport.name === 'ɵinput';
+  return targetImport.name === 'input';
+}
+
+/** Parses and validates the input function options expression. */
+function parseAndValidateOptions(optionsNode: ts.Expression): {alias: string|undefined} {
+  if (!ts.isObjectLiteralExpression(optionsNode)) {
+    throw new FatalDiagnosticError(
+        ErrorCode.VALUE_HAS_WRONG_TYPE, optionsNode,
+        'Argument needs to be an object literal that is statically analyzable.');
+  }
+
+  const options = reflectObjectLiteral(optionsNode);
+  let alias: string|undefined = undefined;
+
+  if (options.has('alias')) {
+    const aliasExpr = options.get('alias')!;
+    if (!ts.isStringLiteralLike(aliasExpr)) {
+      throw new FatalDiagnosticError(
+          ErrorCode.VALUE_HAS_WRONG_TYPE, aliasExpr,
+          'Alias needs to be a string that is statically analyzable.');
+    }
+
+    alias = aliasExpr.text;
+  }
+
+  return {alias};
 }
 
 /**
@@ -118,25 +141,20 @@ function isReferenceToInputFunction(
  */
 export function tryParseSignalInputMapping(
     member: Pick<ClassMember, 'name'|'value'>, reflector: ReflectionHost,
-    evaluator: PartialEvaluator, coreModule: string|undefined): InputMapping|null {
+    coreModule: string|undefined): InputMapping|null {
   const signalInput = tryParseInputInitializerAndOptions(member, reflector, coreModule);
   if (signalInput === null) {
     return null;
   }
 
   const optionsNode = signalInput.optionsNode;
-  const options = optionsNode !== undefined ? evaluator.evaluate(optionsNode) : null;
+  const options = optionsNode !== undefined ? parseAndValidateOptions(optionsNode) : null;
   const classPropertyName = member.name;
 
-  let bindingPropertyName = classPropertyName;
-  if (options instanceof Map && typeof options.get('alias') === 'string') {
-    bindingPropertyName = options.get('alias') as string;
-  }
-
   return {
     isSignal: true,
     classPropertyName,
-    bindingPropertyName,
+    bindingPropertyName: options?.alias ?? classPropertyName,
     required: signalInput.isRequired,
     // Signal inputs do not capture complex transform metadata.
     // See more details in the `transform` type of `InputMapping`.

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

@@ -718,7 +718,7 @@ function tryParseInputFieldMapping(
   const classPropertyName = member.name;
 
   const decorator = tryGetDecoratorOnMember(member, 'Input', coreModule);
-  const signalInputMapping = tryParseSignalInputMapping(member, reflector, evaluator, coreModule);
+  const signalInputMapping = tryParseSignalInputMapping(member, reflector, coreModule);
 
   if (decorator !== null && signalInputMapping !== null) {
     throw new FatalDiagnosticError(

packages/compiler-cli/src/transformers/jit_transforms/signal_inputs_metadata_transform.ts

@@ -34,7 +34,6 @@ const coreModuleName = '@angular/core';
  */
 export function getInputSignalsMetadataTransform(
     host: ReflectionHost,
-    evaluator: PartialEvaluator,
     isCore: boolean,
     ): ts.TransformerFactory<ts.SourceFile> {
   return (ctx) => {
@@ -43,7 +42,7 @@ export function getInputSignalsMetadataTransform(
 
       sourceFile = ts.visitNode(
           sourceFile,
-          createTransformVisitor(ctx, host, evaluator, importManager, isCore),
+          createTransformVisitor(ctx, host, importManager, isCore),
           ts.isSourceFile,
       );
 
@@ -64,7 +63,6 @@ export function getInputSignalsMetadataTransform(
 function createTransformVisitor(
     ctx: ts.TransformationContext,
     host: ReflectionHost,
-    evaluator: PartialEvaluator,
     importManager: ImportManager,
     isCore: boolean,
     ): ts.Visitor<ts.Node, ts.Node> {
@@ -74,8 +72,7 @@ function createTransformVisitor(
           (d) => decoratorsWithInputs.some((name) => isAngularDecorator(d, name, isCore)));
 
       if (angularDecorator !== undefined) {
-        return visitClassDeclaration(
-            ctx, host, evaluator, importManager, node, angularDecorator, isCore);
+        return visitClassDeclaration(ctx, host, importManager, node, angularDecorator, isCore);
       }
     }
 
@@ -88,7 +85,6 @@ function createTransformVisitor(
 function visitClassDeclaration(
     ctx: ts.TransformationContext,
     host: ReflectionHost,
-    evaluator: PartialEvaluator,
     importManager: ImportManager,
     clazz: ts.ClassDeclaration,
     classDecorator: Decorator,
@@ -110,7 +106,6 @@ function visitClassDeclaration(
     const inputMapping = tryParseSignalInputMapping(
         {name: member.name.text, value: member.initializer ?? null},
         host,
-        evaluator,
         isCore ? coreModuleName : undefined,
     );
     if (inputMapping === null) {

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

@@ -70,6 +70,48 @@ runInEachFileSystem(() => {
       ]);
     });
 
+    it('should fail if signal input declares a non-statically analyzable alias', () => {
+      env.write('test.ts', `
+        import {Directive, input} from '@angular/core';
+
+        const ALIAS = 'bla';
+
+        @Directive({
+          inputs: ['data'],
+        })
+        export class TestDir {
+          data = input('test', {alias: ALIAS});
+        }
+      `);
+      const diagnostics = env.driveDiagnostics();
+      expect(diagnostics).toEqual([
+        jasmine.objectContaining({
+          messageText: 'Alias needs to be a string that is statically analyzable.',
+        }),
+      ]);
+    });
+
+    it('should fail if signal input declares a non-statically analyzable options', () => {
+      env.write('test.ts', `
+        import {Directive, input} from '@angular/core';
+
+        const OPTIONS = {};
+
+        @Directive({
+          inputs: ['data'],
+        })
+        export class TestDir {
+          data = input('test', OPTIONS);
+        }
+      `);
+      const diagnostics = env.driveDiagnostics();
+      expect(diagnostics).toEqual([
+        jasmine.objectContaining({
+          messageText: 'Argument needs to be an object literal that is statically analyzable.',
+        }),
+      ]);
+    });
+
     it('should fail if signal input is declared on static member', () => {
       env.write('test.ts', `
         import {Directive, input} from '@angular/core';

packages/compiler-cli/test/signal_inputs_metadata_transform_spec.ts

@@ -8,7 +8,6 @@
 
 import ts from 'typescript';
 
-import {PartialEvaluator} from '../src/ngtsc/partial_evaluator';
 import {TypeScriptReflectionHost} from '../src/ngtsc/reflection';
 import {getDownlevelDecoratorsTransform, getInputSignalsMetadataTransform} from '../src/transformers/jit_transforms';
 
@@ -51,10 +50,9 @@ describe('signal inputs metadata transform', () => {
     const testFile = program.getSourceFile(TEST_FILE_INPUT);
     const typeChecker = program.getTypeChecker();
     const reflectionHost = new TypeScriptReflectionHost(typeChecker);
-    const evaluator = new PartialEvaluator(reflectionHost, typeChecker, null);
     const transformers: ts.CustomTransformers = {
       before: [
-        getInputSignalsMetadataTransform(reflectionHost, evaluator, /* isCore */ false),
+        getInputSignalsMetadataTransform(reflectionHost, /* isCore */ false),
       ]
     };
 
@@ -178,34 +176,6 @@ describe('signal inputs metadata transform', () => {
     `));
   });
 
-  it('should add `@Input` decorator for signal inputs with alias options, resolving ' +
-         'references in input options',
-     () => {
-       const result = transform(`
-        import {input, Directive} from '@angular/core';
-
-        const aliases = {
-          a: 'public1',
-          b: 'public2',
-        }
-
-        @Directive({})
-        class MyDir {
-          someInput = input(null, {alias: aliases.a});
-          someInput2 = input.required<string>({alias: aliases.b});
-        }
-      `);
-
-       expect(result).toContain(omitLeadingWhitespace(`
-        __decorate([
-          i0.Input({ isSignal: true, alias: "public1", required: false, transform: undefined })
-          ], MyDir.prototype, "someInput", void 0);
-        __decorate([
-          i0.Input({ isSignal: true, alias: "public2", required: true, transform: undefined })
-          ], MyDir.prototype, "someInput2", void 0);
-      `));
-     });
-
   it('should not transform signal inputs with an existing `@Input` decorator', () => {
     // This is expected to not happen because technically the TS code for signal inputs
     // should never discover both `@Input` and signal inputs. We handle this gracefully

packages/core/test/acceptance/input_signals/signal_inputs_test_compiler.ts

@@ -30,8 +30,7 @@ async function main() {
   const evaluator = new PartialEvaluator(host, program.getTypeChecker(), null);
   const outputFile = ts.transform(
       program.getSourceFile(inputTsExecPath)!,
-      [getInputSignalsMetadataTransform(host, evaluator, /* isCore */ false)],
-      program.getCompilerOptions());
+      [getInputSignalsMetadataTransform(host, /* isCore */ false)], program.getCompilerOptions());
 
   await fs.promises.writeFile(
       outputExecPath, ts.createPrinter().printFile(outputFile.transformed[0]));