shared.ts

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

import {createMayBeForwardRefExpression, emitDistinctChangesOnlyDefaultValue, Expression, ExternalExpr, ForwardRefHandling, getSafePropertyAccessString, MaybeForwardRefExpression, ParsedHostBindings, ParseError, parseHostBindings, R3DirectiveMetadata, R3HostDirectiveMetadata, R3InputMetadata, R3QueryMetadata, R3Reference, verifyHostBindings, WrappedNodeExpr} from '@angular/compiler';
import ts from 'typescript';

import {ErrorCode, FatalDiagnosticError, makeRelatedInformation} from '../../../diagnostics';
import {assertSuccessfulReferenceEmit, ImportFlags, Reference, ReferenceEmitter} from '../../../imports';
import {ClassPropertyMapping, DecoratorInputTransform, HostDirectiveMeta, InputMapping, InputOrOutput, isHostDirectiveMetaForGlobalMode} from '../../../metadata';
import {DynamicValue, EnumValue, PartialEvaluator, ResolvedValue, traceDynamicValue} from '../../../partial_evaluator';
import {AmbientImport, ClassDeclaration, ClassMember, ClassMemberKind, Decorator, filterToMembersWithDecorator, isNamedClassDeclaration, ReflectionHost, reflectObjectLiteral} from '../../../reflection';
import {CompilationMode} from '../../../transform';
import {createSourceSpan, createValueHasWrongTypeError, forwardRefResolver, getAngularDecorators, getConstructorDependencies, isAngularDecorator, ReferencesRegistry, toR3Reference, tryUnwrapForwardRef, unwrapConstructorDependencies, unwrapExpression, validateConstructorDependencies, assertLocalCompilationUnresolvedConst, wrapFunctionExpressionsInParens, wrapTypeReference} from '../../common';

import {tryParseSignalInputMapping} from './input_function';
import {tryParseInitializerBasedOutput} from './output_function';
import {tryParseSignalQueryFromInitializer} from './query_functions';

const EMPTY_OBJECT: {[key: string]: string} = {};

type QueryDecoratorName = 'ViewChild'|'ViewChildren'|'ContentChild'|'ContentChildren';
export const queryDecoratorNames: QueryDecoratorName[] =
    ['ViewChild', 'ViewChildren', 'ContentChild', 'ContentChildren'];

const QUERY_TYPES = new Set<string>(queryDecoratorNames);

/**
 * Helper function to extract metadata from a `Directive` or `Component`. `Directive`s without a
 * selector are allowed to be used for abstract base classes. These abstract directives should not
 * appear in the declarations of an `NgModule` and additional verification is done when processing
 * the module.
 */
export function extractDirectiveMetadata(
    clazz: ClassDeclaration, decorator: Readonly<Decorator>, reflector: ReflectionHost,
    evaluator: PartialEvaluator, refEmitter: ReferenceEmitter,
    referencesRegistry: ReferencesRegistry, isCore: boolean, annotateForClosureCompiler: boolean,
    compilationMode: CompilationMode, defaultSelector: string|null, useTemplatePipeline: boolean): {
  decorator: Map<string, ts.Expression>,
  metadata: R3DirectiveMetadata,
  inputs: ClassPropertyMapping<InputMapping>,
  outputs: ClassPropertyMapping,
  isStructural: boolean;
  hostDirectives: HostDirectiveMeta[] | null, rawHostDirectives: ts.Expression | null,
}|undefined {
  let directive: Map<string, ts.Expression>;
  if (decorator.args === null || decorator.args.length === 0) {
    directive = new Map<string, ts.Expression>();
  } else if (decorator.args.length !== 1) {
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_ARITY_WRONG, decorator.node,
        `Incorrect number of arguments to @${decorator.name} decorator`);
  } else {
    const meta = unwrapExpression(decorator.args[0]);
    if (!ts.isObjectLiteralExpression(meta)) {
      throw new FatalDiagnosticError(
          ErrorCode.DECORATOR_ARG_NOT_LITERAL, meta,
          `@${decorator.name} argument must be an object literal`);
    }
    directive = reflectObjectLiteral(meta);
  }

  if (directive.has('jit')) {
    // The only allowed value is true, so there's no need to expand further.
    return undefined;
  }

  const members = reflector.getMembersOfClass(clazz);

  // Precompute a list of ts.ClassElements that have decorators. This includes things like @Input,
  // @Output, @HostBinding, etc.
  const decoratedElements =
      members.filter(member => !member.isStatic && member.decorators !== null);

  const coreModule = isCore ? undefined : '@angular/core';

  // Construct the map of inputs both from the @Directive/@Component
  // decorator, and the decorated fields.
  const inputsFromMeta =
      parseInputsArray(clazz, directive, evaluator, reflector, refEmitter, compilationMode);
  const inputsFromFields = parseInputFields(
      clazz, members, evaluator, reflector, refEmitter, isCore, compilationMode, inputsFromMeta,
      decorator);
  const inputs = ClassPropertyMapping.fromMappedObject({...inputsFromMeta, ...inputsFromFields});

  // And outputs.
  const outputsFromMeta = parseOutputsArray(directive, evaluator);
  const outputsFromFields =
      parseOutputFields(clazz, decorator, members, isCore, reflector, evaluator, outputsFromMeta);
  const outputs = ClassPropertyMapping.fromMappedObject({...outputsFromMeta, ...outputsFromFields});

  // Parse queries of fields.
  const {viewQueries, contentQueries} =
      parseQueriesOfClassFields(members, reflector, evaluator, isCore);

  if (directive.has('queries')) {
    const signalQueryFields = new Set(
        [...viewQueries, ...contentQueries].filter(q => q.isSignal).map(q => q.propertyName));
    const queriesFromDecorator =
        extractQueriesFromDecorator(directive.get('queries')!, reflector, evaluator, isCore);

    // Checks if the query is already declared/reserved via class members declaration.
    // If so, we throw a fatal diagnostic error to prevent this unintentional pattern.
    const checkAndUnwrapQuery = (q: {expr: ts.Expression, metadata: R3QueryMetadata}) => {
      if (signalQueryFields.has(q.metadata.propertyName)) {
        throw new FatalDiagnosticError(
            ErrorCode.INITIALIZER_API_DECORATOR_METADATA_COLLISION, q.expr,
            `Query is declared multiple times. "@${
                decorator.name}" declares a query for the same property.`);
      }
      return q.metadata;
    };

    contentQueries.push(...queriesFromDecorator.content.map(q => checkAndUnwrapQuery(q)));
    viewQueries.push(...queriesFromDecorator.view.map(q => checkAndUnwrapQuery(q)));
  }

  // Parse the selector.
  let selector = defaultSelector;
  if (directive.has('selector')) {
    const expr = directive.get('selector')!;
    const resolved = evaluator.evaluate(expr);
    assertLocalCompilationUnresolvedConst(compilationMode, resolved, null,
      'Unresolved identifier found for @Component.selector field! Did you ' + 
      'import this identifier from a file outside of the compilation unit? ' + 
      'This is not allowed when Angular compiler runs in local mode. Possible ' + 
      'solutions: 1) Move the declarations into a file within the compilation ' + 
      'unit, 2) Inline the selector');
    if (typeof resolved !== 'string') {
      throw createValueHasWrongTypeError(expr, resolved, `selector must be a string`);
    }
    // use default selector in case selector is an empty string
    selector = resolved === '' ? defaultSelector : resolved;
    if (!selector) {
      throw new FatalDiagnosticError(
          ErrorCode.DIRECTIVE_MISSING_SELECTOR, expr,
          `Directive ${clazz.name.text} has no selector, please add it!`);
    }
  }

  const host = extractHostBindings(decoratedElements, evaluator, coreModule, compilationMode, directive);

  const providers: Expression|null = directive.has('providers') ?
      new WrappedNodeExpr(
          annotateForClosureCompiler ?
              wrapFunctionExpressionsInParens(directive.get('providers')!) :
              directive.get('providers')!) :
      null;

  // Determine if `ngOnChanges` is a lifecycle hook defined on the component.
  const usesOnChanges = members.some(
      member => !member.isStatic && member.kind === ClassMemberKind.Method &&
          member.name === 'ngOnChanges');

  // Parse exportAs.
  let exportAs: string[]|null = null;
  if (directive.has('exportAs')) {
    const expr = directive.get('exportAs')!;
    const resolved = evaluator.evaluate(expr);
    if (typeof resolved !== 'string') {
      throw createValueHasWrongTypeError(expr, resolved, `exportAs must be a string`);
    }
    exportAs = resolved.split(',').map(part => part.trim());
  }

  const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);

  // Non-abstract directives (those with a selector) require valid constructor dependencies, whereas
  // abstract directives are allowed to have invalid dependencies, given that a subclass may call
  // the constructor explicitly.
  const ctorDeps = selector !== null ? validateConstructorDependencies(clazz, rawCtorDeps) :
                                       unwrapConstructorDependencies(rawCtorDeps);

  // Structural directives must have a `TemplateRef` dependency.
  const isStructural = ctorDeps !== null && ctorDeps !== 'invalid' &&
      ctorDeps.some(
          dep => (dep.token instanceof ExternalExpr) &&
              dep.token.value.moduleName === '@angular/core' &&
              dep.token.value.name === 'TemplateRef');

  let isStandalone = false;
  if (directive.has('standalone')) {
    const expr = directive.get('standalone')!;
    const resolved = evaluator.evaluate(expr);
    if (typeof resolved !== 'boolean') {
      throw createValueHasWrongTypeError(expr, resolved, `standalone flag must be a boolean`);
    }
    isStandalone = resolved;
  }
  let isSignal = false;
  if (directive.has('signals')) {
    const expr = directive.get('signals')!;
    const resolved = evaluator.evaluate(expr);
    if (typeof resolved !== 'boolean') {
      throw createValueHasWrongTypeError(expr, resolved, `signals flag must be a boolean`);
    }
    isSignal = resolved;
  }

  // Detect if the component inherits from another class
  const usesInheritance = reflector.hasBaseClass(clazz);
  const sourceFile = clazz.getSourceFile();
  const type = wrapTypeReference(reflector, clazz);

  const rawHostDirectives = directive.get('hostDirectives') || null;
  const hostDirectives = rawHostDirectives === null ?
      null :
      extractHostDirectives(rawHostDirectives, evaluator, compilationMode);

  if (compilationMode !== CompilationMode.LOCAL && hostDirectives !== null) {
    // In global compilation mode where we do type checking, the template type-checker will need to
    // import host directive types, so add them as referenced by `clazz`. This will ensure that
    // libraries are required to export host directives which are visible from publicly exported
    // components.
    referencesRegistry.add(clazz, ...hostDirectives.map(hostDir => {
      if (!isHostDirectiveMetaForGlobalMode(hostDir)) {
        throw new Error('Impossible state');
      }

      return hostDir.directive;
    }));
  }

  const metadata: R3DirectiveMetadata = {
    name: clazz.name.text,
    deps: ctorDeps,
    host: {
      ...host,
      useTemplatePipeline,
    },
    lifecycle: {
      usesOnChanges,
    },
    inputs: inputs.toJointMappedObject(toR3InputMetadata),
    outputs: outputs.toDirectMappedObject(),
    queries: contentQueries,
    viewQueries,
    selector,
    fullInheritance: false,
    type,
    typeArgumentCount: reflector.getGenericArityOfClass(clazz) || 0,
    typeSourceSpan: createSourceSpan(clazz.name),
    usesInheritance,
    exportAs,
    providers,
    isStandalone,
    isSignal,
    hostDirectives:
        hostDirectives?.map(hostDir => toHostDirectiveMetadata(hostDir, sourceFile, refEmitter)) ||
        null,
  };
  return {
    decorator: directive,
    metadata,
    inputs,
    outputs,
    isStructural,
    hostDirectives,
    rawHostDirectives,
  };
}

export function extractDecoratorQueryMetadata(
    exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string,
    reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata {
  if (args.length === 0) {
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_ARITY_WRONG, exprNode, `@${name} must have arguments`);
  }
  const first = name === 'ViewChild' || name === 'ContentChild';
  const forwardReferenceTarget = tryUnwrapForwardRef(args[0], reflector);
  const node = forwardReferenceTarget ?? args[0];

  const arg = evaluator.evaluate(node);

  /** Whether or not this query should collect only static results (see view/api.ts)  */
  let isStatic: boolean = false;

  // Extract the predicate
  let predicate: MaybeForwardRefExpression|string[]|null = null;
  if (arg instanceof Reference || arg instanceof DynamicValue) {
    // References and predicates that could not be evaluated statically are emitted as is.
    predicate = createMayBeForwardRefExpression(
        new WrappedNodeExpr(node),
        forwardReferenceTarget !== null ? ForwardRefHandling.Unwrapped : ForwardRefHandling.None);
  } else if (typeof arg === 'string') {
    predicate = [arg];
  } else if (isStringArrayOrDie(arg, `@${name} predicate`, node)) {
    predicate = arg;
  } else {
    throw createValueHasWrongTypeError(node, arg, `@${name} predicate cannot be interpreted`);
  }

  // Extract the read and descendants options.
  let read: Expression|null = null;
  // The default value for descendants is true for every decorator except @ContentChildren.
  let descendants: boolean = name !== 'ContentChildren';
  let emitDistinctChangesOnly: boolean = emitDistinctChangesOnlyDefaultValue;
  if (args.length === 2) {
    const optionsExpr = unwrapExpression(args[1]);
    if (!ts.isObjectLiteralExpression(optionsExpr)) {
      throw new FatalDiagnosticError(
          ErrorCode.DECORATOR_ARG_NOT_LITERAL, optionsExpr,
          `@${name} options must be an object literal`);
    }
    const options = reflectObjectLiteral(optionsExpr);
    if (options.has('read')) {
      read = new WrappedNodeExpr(options.get('read')!);
    }

    if (options.has('descendants')) {
      const descendantsExpr = options.get('descendants')!;
      const descendantsValue = evaluator.evaluate(descendantsExpr);
      if (typeof descendantsValue !== 'boolean') {
        throw createValueHasWrongTypeError(
            descendantsExpr, descendantsValue, `@${name} options.descendants must be a boolean`);
      }
      descendants = descendantsValue;
    }

    if (options.has('emitDistinctChangesOnly')) {
      const emitDistinctChangesOnlyExpr = options.get('emitDistinctChangesOnly')!;
      const emitDistinctChangesOnlyValue = evaluator.evaluate(emitDistinctChangesOnlyExpr);
      if (typeof emitDistinctChangesOnlyValue !== 'boolean') {
        throw createValueHasWrongTypeError(
            emitDistinctChangesOnlyExpr, emitDistinctChangesOnlyValue,
            `@${name} options.emitDistinctChangesOnly must be a boolean`);
      }
      emitDistinctChangesOnly = emitDistinctChangesOnlyValue;
    }

    if (options.has('static')) {
      const staticValue = evaluator.evaluate(options.get('static')!);
      if (typeof staticValue !== 'boolean') {
        throw createValueHasWrongTypeError(
            node, staticValue, `@${name} options.static must be a boolean`);
      }
      isStatic = staticValue;
    }

  } else if (args.length > 2) {
    // Too many arguments.
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_ARITY_WRONG, node, `@${name} has too many arguments`);
  }

  return {
    isSignal: false,
    propertyName,
    predicate,
    first,
    descendants,
    read,
    static: isStatic,
    emitDistinctChangesOnly,
  };
}


export function extractHostBindings(
    members: ClassMember[], evaluator: PartialEvaluator, coreModule: string|undefined, compilationMode: CompilationMode, metadata?: Map<string, ts.Expression>): ParsedHostBindings {
  let bindings: ParsedHostBindings;
  if (metadata && metadata.has('host')) {
    bindings = evaluateHostExpressionBindings(metadata.get('host')!, evaluator);
  } else {
    bindings = parseHostBindings({});
  }

  filterToMembersWithDecorator(members, 'HostBinding', coreModule)
      .forEach(({member, decorators}) => {
        decorators.forEach(decorator => {
          let hostPropertyName: string = member.name;
          if (decorator.args !== null && decorator.args.length > 0) {
            if (decorator.args.length !== 1) {
              throw new FatalDiagnosticError(
                  ErrorCode.DECORATOR_ARITY_WRONG, decorator.node,
                  `@HostBinding can have at most one argument, got ${
                      decorator.args.length} argument(s)`);
            }

            const resolved = evaluator.evaluate(decorator.args[0]);
            if (typeof resolved !== 'string') {
              throw createValueHasWrongTypeError(
                  decorator.node, resolved, `@HostBinding's argument must be a string`);
            }

            hostPropertyName = resolved;
          }

          // Since this is a decorator, we know that the value is a class member. Always access it
          // through `this` so that further down the line it can't be confused for a literal value
          // (e.g. if there's a property called `true`). There is no size penalty, because all
          // values (except literals) are converted to `ctx.propName` eventually.
          bindings.properties[hostPropertyName] = getSafePropertyAccessString('this', member.name);
        });
      });

  filterToMembersWithDecorator(members, 'HostListener', coreModule)
      .forEach(({member, decorators}) => {
        decorators.forEach(decorator => {
          let eventName: string = member.name;
          let args: string[] = [];
          if (decorator.args !== null && decorator.args.length > 0) {
            if (decorator.args.length > 2) {
              throw new FatalDiagnosticError(
                  ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2],
                  `@HostListener can have at most two arguments`);
            }

            const resolved = evaluator.evaluate(decorator.args[0]);

            // Specific error for local compilation mode if the event name cannot be resolved
            assertLocalCompilationUnresolvedConst(compilationMode, resolved, null, 
              'Unresolved identifier found for @HostListener\'s event name ' + 
              'argument! Did you import this identifier from a file outside of ' + 
              'the compilation unit? This is not allowed when Angular compiler ' + 
              'runs in local mode. Possible solutions: 1) Move the declaration ' + 
              'into a file within the compilation unit, 2) Inline the argument');

            if (typeof resolved !== 'string') {
              throw createValueHasWrongTypeError(
                  decorator.args[0], resolved,
                  `@HostListener's event name argument must be a string`);
            }

            eventName = resolved;

            if (decorator.args.length === 2) {
              const expression = decorator.args[1];
              const resolvedArgs = evaluator.evaluate(decorator.args[1]);
              if (!isStringArrayOrDie(resolvedArgs, '@HostListener.args', expression)) {
                throw createValueHasWrongTypeError(
                    decorator.args[1], resolvedArgs,
                    `@HostListener's second argument must be a string array`);
              }
              args = resolvedArgs;
            }
          }

          bindings.listeners[eventName] = `${member.name}(${args.join(',')})`;
        });
      });
  return bindings;
}

function extractQueriesFromDecorator(
    queryData: ts.Expression, reflector: ReflectionHost, evaluator: PartialEvaluator,
    isCore: boolean): {
  content: {expr: ts.Expression, metadata: R3QueryMetadata}[],
  view: {expr: ts.Expression, metadata: R3QueryMetadata}[],
} {
  const content: {expr: ts.Expression, metadata: R3QueryMetadata}[] = [];
  const view: {expr: ts.Expression, metadata: R3QueryMetadata}[] = [];

  if (!ts.isObjectLiteralExpression(queryData)) {
    throw new FatalDiagnosticError(
        ErrorCode.VALUE_HAS_WRONG_TYPE, queryData,
        'Decorator queries metadata must be an object literal');
  }
  reflectObjectLiteral(queryData).forEach((queryExpr, propertyName) => {
    queryExpr = unwrapExpression(queryExpr);
    if (!ts.isNewExpression(queryExpr)) {
      throw new FatalDiagnosticError(
          ErrorCode.VALUE_HAS_WRONG_TYPE, queryData,
          'Decorator query metadata must be an instance of a query type');
    }
    const queryType = ts.isPropertyAccessExpression(queryExpr.expression) ?
        queryExpr.expression.name :
        queryExpr.expression;
    if (!ts.isIdentifier(queryType)) {
      throw new FatalDiagnosticError(
          ErrorCode.VALUE_HAS_WRONG_TYPE, queryData,
          'Decorator query metadata must be an instance of a query type');
    }
    const type = reflector.getImportOfIdentifier(queryType);
    if (type === null || (!isCore && type.from !== '@angular/core') ||
        !QUERY_TYPES.has(type.name)) {
      throw new FatalDiagnosticError(
          ErrorCode.VALUE_HAS_WRONG_TYPE, queryData,
          'Decorator query metadata must be an instance of a query type');
    }

    const query = extractDecoratorQueryMetadata(
        queryExpr, type.name, queryExpr.arguments || [], propertyName, reflector, evaluator);
    if (type.name.startsWith('Content')) {
      content.push({expr: queryExpr, metadata: query});
    } else {
      view.push({expr: queryExpr, metadata: query});
    }
  });
  return {content, view};
}

export function parseDirectiveStyles(
    directive: Map<string, ts.Expression>, evaluator: PartialEvaluator,
    compilationMode: CompilationMode): null|string[] {
  const expression = directive.get('styles');

  if (!expression) {
    return null;
  }

  const evaluated = evaluator.evaluate(expression);
  const value = typeof evaluated === 'string' ? [evaluated] : evaluated;

  // Check if the identifier used for @Component.styles cannot be resolved in local compilation mode. if the case, an error specific to this situation is generated.
  if (compilationMode === CompilationMode.LOCAL) {
    let unresolvedNode: ts.Node|null = null;
    if (Array.isArray(value)) {
      const entry = value.find(e => e instanceof DynamicValue && e.isFromUnknownIdentifier()) as DynamicValue|undefined;
      unresolvedNode = entry?.node ?? null;
    } else if (value instanceof DynamicValue && value.isFromUnknownIdentifier()) {
      unresolvedNode = value.node;
    }
    
    if (unresolvedNode !== null) {
      throw new FatalDiagnosticError(
          ErrorCode.LOCAL_COMPILATION_UNRESOLVED_CONST, 
          unresolvedNode, 
          'Unresolved identifier found for @Component.styles field! Did you import ' + 
          'this identifier from a file outside of the compilation unit? This is ' + 
          'not allowed when Angular compiler runs in local mode. Possible ' + 
          'solutions: 1) Move the declarations into a file within the compilation ' + 
          'unit, 2) Inline the styles, 3) Move the styles into separate files and ' + 
          'include it using @Component.styleUrls');
    }
  }

  if (!isStringArrayOrDie(value, 'styles', expression)) {
    throw createValueHasWrongTypeError(
        expression, value,
        `Failed to resolve @Component.styles to a string or an array of strings`);
  }

  return value;
}

export function parseFieldStringArrayValue(
    directive: Map<string, ts.Expression>, field: string, evaluator: PartialEvaluator): null|
    string[] {
  if (!directive.has(field)) {
    return null;
  }

  // Resolve the field of interest from the directive metadata to a string[].
  const expression = directive.get(field)!;
  const value = evaluator.evaluate(expression);
  if (!isStringArrayOrDie(value, field, expression)) {
    throw createValueHasWrongTypeError(
        expression, value, `Failed to resolve @Directive.${field} to a string array`);
  }

  return value;
}

function isStringArrayOrDie(value: any, name: string, node: ts.Expression): value is string[] {
  if (!Array.isArray(value)) {
    return false;
  }

  for (let i = 0; i < value.length; i++) {
    if (typeof value[i] !== 'string') {
      throw createValueHasWrongTypeError(
          node, value[i], `Failed to resolve ${name} at position ${i} to a string`);
    }
  }
  return true;
}

function tryGetQueryFromFieldDecorator(
    member: ClassMember, reflector: ReflectionHost, evaluator: PartialEvaluator, isCore: boolean):
    {name: QueryDecoratorName, decorator: Decorator, metadata: R3QueryMetadata}|null {
  const decorators = member.decorators;
  if (decorators === null) {
    return null;
  }

  const queryDecorators = getAngularDecorators(decorators, queryDecoratorNames, isCore);
  if (queryDecorators.length === 0) {
    return null;
  }
  if (queryDecorators.length !== 1) {
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_COLLISION, member.node ?? queryDecorators[0].node,
        'Cannot combine multiple query decorators.');
  }

  const decorator = queryDecorators[0];
  const node = member.node || decorator.node;

  // Throw in case of `@Input() @ContentChild('foo') foo: any`, which is not supported in Ivy
  if (decorators.some(v => v.name === 'Input')) {
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_COLLISION, node,
        'Cannot combine @Input decorators with query decorators');
  }
  if (!isPropertyTypeMember(member)) {
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_UNEXPECTED, node, 'Query decorator must go on a property-type member');
  }

  // Either the decorator was aliased, or is referenced directly with
  // the proper query name.
  const name = (decorator.import?.name ?? decorator.name) as QueryDecoratorName;

  return {
    name,
    decorator,
    metadata: extractDecoratorQueryMetadata(
        node, name, decorator.args || [], member.name, reflector, evaluator),
  };
}

function isPropertyTypeMember(member: ClassMember): boolean {
  return member.kind === ClassMemberKind.Getter || member.kind === ClassMemberKind.Setter ||
      member.kind === ClassMemberKind.Property;
}

function parseMappingStringArray(values: string[]) {
  return values.reduce((results, value) => {
    if (typeof value !== 'string') {
      throw new Error('Mapping value must be a string');
    }

    const [bindingPropertyName, fieldName] = parseMappingString(value);
    results[fieldName] = bindingPropertyName;
    return results;
  }, {} as {[field: string]: string});
}

function parseMappingString(value: string): [bindingPropertyName: string, fieldName: string] {
  // Either the value is 'field' or 'field: property'. In the first case, `property` will
  // be undefined, in which case the field name should also be used as the property name.
  const [fieldName, bindingPropertyName] = value.split(':', 2).map(str => str.trim());
  return [bindingPropertyName ?? fieldName, fieldName];
}

/** Parses the `inputs` array of a directive/component decorator. */
function parseInputsArray(
    clazz: ClassDeclaration, decoratorMetadata: Map<string, ts.Expression>,
    evaluator: PartialEvaluator, reflector: ReflectionHost, refEmitter: ReferenceEmitter,
    compilationMode: CompilationMode): Record<string, InputMapping> {
  const inputsField = decoratorMetadata.get('inputs');

  if (inputsField === undefined) {
    return {};
  }

  const inputs = {} as Record<string, InputMapping>;
  const inputsArray = evaluator.evaluate(inputsField);

  if (!Array.isArray(inputsArray)) {
    throw createValueHasWrongTypeError(
        inputsField, inputsArray, `Failed to resolve @Directive.inputs to an array`);
  }

  for (let i = 0; i < inputsArray.length; i++) {
    const value = inputsArray[i];

    if (typeof value === 'string') {
      // If the value is a string, we treat it as a mapping string.
      const [bindingPropertyName, classPropertyName] = parseMappingString(value);
      inputs[classPropertyName] = {
        bindingPropertyName,
        classPropertyName,
        required: false,
        transform: null,
        // Note: Signal inputs are not allowed with the array form.
        isSignal: false,
      };
    } else if (value instanceof Map) {
      // If it's a map, we treat it as a config object.
      const name = value.get('name');
      const alias = value.get('alias');
      const required = value.get('required');
      let transform: DecoratorInputTransform|null = null;

      if (typeof name !== 'string') {
        throw createValueHasWrongTypeError(
            inputsField, name,
            `Value at position ${i} of @Directive.inputs array must have a "name" property`);
      }

      if (value.has('transform')) {
        const transformValue = value.get('transform');

        if (!(transformValue instanceof DynamicValue) && !(transformValue instanceof Reference)) {
          throw createValueHasWrongTypeError(
              inputsField, transformValue,
              `Transform of value at position ${i} of @Directive.inputs array must be a function`);
        }

        transform = parseDecoratorInputTransformFunction(
            clazz, name, transformValue, reflector, refEmitter, compilationMode);
      }

      inputs[name] = {
        classPropertyName: name,
        bindingPropertyName: typeof alias === 'string' ? alias : name,
        required: required === true,
        // Note: Signal inputs are not allowed with the array form.
        isSignal: false,
        transform,
      };
    } else {
      throw createValueHasWrongTypeError(
          inputsField, value,
          `@Directive.inputs array can only contain strings or object literals`);
    }
  }

  return inputs;
}

/** Attempts to find a given Angular decorator on the class member. */
function tryGetDecoratorOnMember(
    member: ClassMember, decoratorName: string, isCore: boolean): Decorator|null {
  if (member.decorators === null) {
    return null;
  }

  for (const decorator of member.decorators) {
    if (isAngularDecorator(decorator, decoratorName, isCore)) {
      return decorator;
    }
  }
  return null;
}

function tryParseInputFieldMapping(
    clazz: ClassDeclaration, member: ClassMember, evaluator: PartialEvaluator,
    reflector: ReflectionHost, isCore: boolean, refEmitter: ReferenceEmitter,
    compilationMode: CompilationMode): InputMapping|null {
  const classPropertyName = member.name;

  const decorator = tryGetDecoratorOnMember(member, 'Input', isCore);
  const signalInputMapping = tryParseSignalInputMapping(member, reflector, isCore);

  if (decorator !== null && signalInputMapping !== null) {
    throw new FatalDiagnosticError(
        ErrorCode.INITIALIZER_API_WITH_DISALLOWED_DECORATOR, decorator.node,
        `Using @Input with a signal input is not allowed.`);
  }

  // Check `@Input` case.
  if (decorator !== null) {
    if (decorator.args !== null && decorator.args.length > 1) {
      throw new FatalDiagnosticError(
          ErrorCode.DECORATOR_ARITY_WRONG, decorator.node,
          `@${decorator.name} can have at most one argument, got ${
              decorator.args.length} argument(s)`);
    }

    const optionsNode =
        decorator.args !== null && decorator.args.length === 1 ? decorator.args[0] : undefined;
    const options = optionsNode !== undefined ? evaluator.evaluate(optionsNode) : null;
    const required = options instanceof Map ? options.get('required') === true : false;

    // To preserve old behavior: Even though TypeScript types ensure proper options are
    // passed, we sanity check for unsupported values here again.
    if (options !== null && typeof options !== 'string' && !(options instanceof Map)) {
      throw createValueHasWrongTypeError(
          decorator.node, options,
          `@${decorator.name} decorator argument must resolve to a string or an object literal`);
    }

    let alias: string|null = null;
    if (typeof options === 'string') {
      alias = options;
    } else if (options instanceof Map && typeof options.get('alias') === 'string') {
      alias = options.get('alias') as string;
    }

    const publicInputName = alias ?? classPropertyName;

    let transform: DecoratorInputTransform|null = null;
    if (options instanceof Map && options.has('transform')) {
      const transformValue = options.get('transform');

      if (!(transformValue instanceof DynamicValue) && !(transformValue instanceof Reference)) {
        throw createValueHasWrongTypeError(
            optionsNode!, transformValue, `Input transform must be a function`);
      }

      transform = parseDecoratorInputTransformFunction(
          clazz, classPropertyName, transformValue, reflector, refEmitter, compilationMode);
    }

    return {
      isSignal: false,
      classPropertyName,
      bindingPropertyName: publicInputName,
      transform,
      required,
    };
  }

  // Look for signal inputs. e.g. `memberName = input()`
  if (signalInputMapping !== null) {
    return signalInputMapping;
  }

  return null;
}

/** Parses the class members that declare inputs (via decorator or initializer). */
function parseInputFields(
    clazz: ClassDeclaration, members: ClassMember[], evaluator: PartialEvaluator,
    reflector: ReflectionHost, refEmitter: ReferenceEmitter, isCore: boolean,
    compilationMode: CompilationMode, inputsFromClassDecorator: Record<string, InputMapping>,
    classDecorator: Decorator): Record<string, InputMapping> {
  const inputs = {} as Record<string, InputMapping>;

  for (const member of members) {
    const classPropertyName = member.name;
    const inputMapping = tryParseInputFieldMapping(
        clazz,
        member,
        evaluator,
        reflector,
        isCore,
        refEmitter,
        compilationMode,
    );
    if (inputMapping === null) {
      continue;
    }

    if (member.isStatic) {
      throw new FatalDiagnosticError(
          ErrorCode.INCORRECTLY_DECLARED_ON_STATIC_MEMBER, member.node ?? clazz,
          `Input "${member.name}" is incorrectly declared as static member of "${
              clazz.name.text}".`);
    }

    // Validate that signal inputs are not accidentally declared in the `inputs` metadata.
    if (inputMapping.isSignal && inputsFromClassDecorator.hasOwnProperty(classPropertyName)) {
      throw new FatalDiagnosticError(
          ErrorCode.INITIALIZER_API_DECORATOR_METADATA_COLLISION, member.node ?? clazz,
          `Input "${member.name}" is also declared as non-signal in @${classDecorator.name}.`);
    }

    inputs[classPropertyName] = inputMapping;
  }

  return inputs;
}

/**
 * Parses the `transform` function and its type for a decorator `@Input`.
 *
 * This logic verifies feasibility of extracting the transform write type
 * into a different place, so that the input write type can be captured at
 * a later point in a static acceptance member.
 *
 * Note: This is not needed for signal inputs where the transform type is
 * automatically captured in the type of the `InputSignal`.
 *
 */
export function parseDecoratorInputTransformFunction(
    clazz: ClassDeclaration, classPropertyName: string, value: DynamicValue|Reference,
    reflector: ReflectionHost, refEmitter: ReferenceEmitter,
    compilationMode: CompilationMode): DecoratorInputTransform {
  // 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
  // all the diagnostics.
  if (compilationMode === CompilationMode.LOCAL) {
    const node =
        value instanceof Reference ? value.getIdentityIn(clazz.getSourceFile()) : value.node;

    // This should never be null since we know the reference originates
    // from the same file, but we null check it just in case.
    if (node === null) {
      throw createValueHasWrongTypeError(
          value.node, value, 'Input transform function could not be referenced');
    }

    return {
      node,
      type: new Reference(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))
    };
  }

  const definition = reflector.getDefinitionOfFunction(value.node);

  if (definition === null) {
    throw createValueHasWrongTypeError(value.node, value, 'Input transform must be a function');
  }

  if (definition.typeParameters !== null && definition.typeParameters.length > 0) {
    throw createValueHasWrongTypeError(
        value.node, value, 'Input transform function cannot be generic');
  }

  if (definition.signatureCount > 1) {
    throw createValueHasWrongTypeError(
        value.node, value, 'Input transform function cannot have multiple signatures');
  }

  const members = reflector.getMembersOfClass(clazz);

  for (const member of members) {
    const conflictingName = `ngAcceptInputType_${classPropertyName}`;

    if (member.name === conflictingName && member.isStatic) {
      throw new FatalDiagnosticError(
          ErrorCode.CONFLICTING_INPUT_TRANSFORM, value.node,
          `Class cannot have both a transform function on Input ${
              classPropertyName} and a static member called ${conflictingName}`);
    }
  }

  const node = value instanceof Reference ? value.getIdentityIn(clazz.getSourceFile()) : value.node;

  // This should never be null since we know the reference originates
  // from the same file, but we null check it just in case.
  if (node === null) {
    throw createValueHasWrongTypeError(
        value.node, value, 'Input transform function could not be referenced');
  }

  // Skip over `this` parameters since they're typing the context, not the actual parameter.
  // `this` parameters are guaranteed to be first if they exist, and the only to distinguish them
  // is using the name, TS doesn't have a special AST for them.
  const firstParam = definition.parameters[0]?.name === 'this' ? definition.parameters[1] :
                                                                 definition.parameters[0];

  // Treat functions with no arguments as `unknown` since returning
  // the same value from the transform function is valid.
  if (!firstParam) {
    return {
      node,
      type: new Reference(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))
    };
  }

  // This should be caught by `noImplicitAny` already, but null check it just in case.
  if (!firstParam.type) {
    throw createValueHasWrongTypeError(
        value.node, value, 'Input transform function first parameter must have a type');
  }

  if (firstParam.node.dotDotDotToken) {
    throw createValueHasWrongTypeError(
        value.node, value, 'Input transform function first parameter cannot be a spread parameter');
  }

  assertEmittableInputType(firstParam.type, clazz.getSourceFile(), reflector, refEmitter);

  const viaModule = value instanceof Reference ? value.bestGuessOwningModule : null;
  return {node, type: new Reference(firstParam.type, viaModule)};
}

/**
 * Verifies that a type and all types contained within
 * it can be referenced in a specific context file.
 */
function assertEmittableInputType(
    type: ts.TypeNode, contextFile: ts.SourceFile, reflector: ReflectionHost,
    refEmitter: ReferenceEmitter): void {
  (function walk(node: ts.Node) {
    if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
      const declaration = reflector.getDeclarationOfIdentifier(node.typeName);

      if (declaration !== null) {
        // If the type is declared in a different file, we have to check that it can be imported
        // into the context file. If they're in the same file, we need to verify that they're
        // exported, otherwise TS won't emit it to the .d.ts.
        if (declaration.node.getSourceFile() !== contextFile) {
          const emittedType = refEmitter.emit(
              new Reference(
                  declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : null),
              contextFile,
              ImportFlags.NoAliasing | ImportFlags.AllowTypeImports |
                  ImportFlags.AllowRelativeDtsImports | ImportFlags.AllowAmbientReferences);

          assertSuccessfulReferenceEmit(emittedType, node, 'type');
        } else if (!reflector.isStaticallyExported(declaration.node)) {
          throw new FatalDiagnosticError(
              ErrorCode.SYMBOL_NOT_EXPORTED, type,
              `Symbol must be exported in order to be used as the type of an Input transform function`,
              [makeRelatedInformation(declaration.node, `The symbol is declared here.`)]);
        }
      }
    }

    node.forEachChild(walk);
  })(type);
}

/**
 * Iterates through all specified class members and attempts to detect
 * view and content queries defined.
 *
 * Queries may be either defined via decorators, or through class member
 * initializers for signal-based queries.
 */
function parseQueriesOfClassFields(
    members: ClassMember[], reflector: ReflectionHost, evaluator: PartialEvaluator,
    isCore: boolean): {
  viewQueries: R3QueryMetadata[],
  contentQueries: R3QueryMetadata[],
} {
  const viewQueries: R3QueryMetadata[] = [];
  const contentQueries: R3QueryMetadata[] = [];

  // For backwards compatibility, decorator-based queries are grouped and
  // ordered in a specific way. The order needs to match with what we had in:
  // https://github.com/angular/angular/blob/8737544d6963bf664f752de273e919575cca08ac/packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.ts#L94-L111.
  const decoratorViewChild: R3QueryMetadata[] = [];
  const decoratorViewChildren: R3QueryMetadata[] = [];
  const decoratorContentChild: R3QueryMetadata[] = [];
  const decoratorContentChildren: R3QueryMetadata[] = [];

  for (const member of members) {
    const decoratorQuery = tryGetQueryFromFieldDecorator(member, reflector, evaluator, isCore);
    const signalQuery = tryParseSignalQueryFromInitializer(member, reflector, isCore);

    if (decoratorQuery !== null && signalQuery !== null) {
      throw new FatalDiagnosticError(
          ErrorCode.INITIALIZER_API_WITH_DISALLOWED_DECORATOR, decoratorQuery.decorator.node,
          `Using @${decoratorQuery.name} with a signal-based query is not allowed.`);
    }

    const queryNode = decoratorQuery?.decorator.node ?? signalQuery?.call;
    if (queryNode !== undefined && member.isStatic) {
      throw new FatalDiagnosticError(
          ErrorCode.INCORRECTLY_DECLARED_ON_STATIC_MEMBER, queryNode,
          `Query is incorrectly declared on a static class member.`);
    }

    if (decoratorQuery !== null) {
      switch (decoratorQuery.name) {
        case 'ViewChild':
          decoratorViewChild.push(decoratorQuery.metadata);
          break;
        case 'ViewChildren':
          decoratorViewChildren.push(decoratorQuery.metadata);
          break;
        case 'ContentChild':
          decoratorContentChild.push(decoratorQuery.metadata);
          break;
        case 'ContentChildren':
          decoratorContentChildren.push(decoratorQuery.metadata);
          break;
      }
    } else if (signalQuery !== null) {
      switch (signalQuery.name) {
        case 'viewChild':
        case 'viewChildren':
          viewQueries.push(signalQuery.metadata);
          break;
        case 'contentChild':
        case 'contentChildren':
          contentQueries.push(signalQuery.metadata);
          break;
      }
    }
  }

  return {
    viewQueries: [...viewQueries, ...decoratorViewChild, ...decoratorViewChildren],
    contentQueries: [...contentQueries, ...decoratorContentChild, ...decoratorContentChildren],
  };
}

/** Parses the `outputs` array of a directive/component. */
function parseOutputsArray(
    directive: Map<string, ts.Expression>, evaluator: PartialEvaluator): Record<string, string> {
  const metaValues = parseFieldStringArrayValue(directive, 'outputs', evaluator);
  return metaValues ? parseMappingStringArray(metaValues) : EMPTY_OBJECT;
}

/** Parses the class members that are outputs. */
function parseOutputFields(
    clazz: ClassDeclaration, classDecorator: Decorator, members: ClassMember[], isCore: boolean,
    reflector: ReflectionHost, evaluator: PartialEvaluator,
    outputsFromMeta: Record<string, string>): Record<string, string> {
  const outputs = {} as Record<string, string>;

  for (const member of members) {
    const decoratorOutput = tryParseDecoratorOutput(member, evaluator, isCore);
    const initializerOutput = tryParseInitializerBasedOutput(member, reflector, isCore);

    if (decoratorOutput !== null && initializerOutput !== null) {
      throw new FatalDiagnosticError(
          ErrorCode.INITIALIZER_API_WITH_DISALLOWED_DECORATOR, decoratorOutput.decorator.node,
          `Using "@Output" with "output()" is not allowed.`);
    }

    const queryNode = decoratorOutput?.decorator.node ?? initializerOutput?.call;
    if (queryNode !== undefined && member.isStatic) {
      throw new FatalDiagnosticError(
          ErrorCode.INCORRECTLY_DECLARED_ON_STATIC_MEMBER, queryNode,
          `Output is incorrectly declared on a static class member.`);
    }

    const metadata = (decoratorOutput ?? initializerOutput)?.metadata;
    if (metadata === undefined) {
      continue;
    }

    // Validate that initializer-based outputs are not accidentally declared
    // in the `outputs` class metadata.
    if (initializerOutput !== null && outputsFromMeta.hasOwnProperty(metadata.classPropertyName)) {
      throw new FatalDiagnosticError(
          ErrorCode.INITIALIZER_API_DECORATOR_METADATA_COLLISION, member.node ?? clazz,
          `Output "${member.name}" is unexpectedly declared in @${classDecorator.name} as well.`);
    }

    outputs[metadata?.classPropertyName] = metadata.bindingPropertyName;
  }

  return outputs;
}

/** Attempts to parse a decorator-based @Output. */
function tryParseDecoratorOutput(member: ClassMember, evaluator: PartialEvaluator, isCore: boolean):
    {decorator: Decorator, metadata: InputOrOutput}|null {
  const decorator = tryGetDecoratorOnMember(member, 'Output', isCore);
  if (decorator === null) {
    return null;
  }
  if (decorator.args !== null && decorator.args.length > 1) {
    throw new FatalDiagnosticError(
        ErrorCode.DECORATOR_ARITY_WRONG, decorator.node,
        `@Output can have at most one argument, got ${decorator.args.length} argument(s)`);
  }

  const classPropertyName = member.name;

  let alias: string|null = null;
  if (decorator.args?.length === 1) {
    const resolvedAlias = evaluator.evaluate(decorator.args[0]);
    if (typeof resolvedAlias !== 'string') {
      throw createValueHasWrongTypeError(
          decorator.node, resolvedAlias, `@Output decorator argument must resolve to a string`);
    }
    alias = resolvedAlias;
  }

  return {
    decorator,
    metadata: {
      isSignal: false,
      classPropertyName,
      bindingPropertyName: alias ?? classPropertyName,
    }
  };
}

function evaluateHostExpressionBindings(
    hostExpr: ts.Expression, evaluator: PartialEvaluator): ParsedHostBindings {
  const hostMetaMap = evaluator.evaluate(hostExpr);
  if (!(hostMetaMap instanceof Map)) {
    throw createValueHasWrongTypeError(
        hostExpr, hostMetaMap, `Decorator host metadata must be an object`);
  }
  const hostMetadata: Record<string, string|Expression> = {};
  hostMetaMap.forEach((value, key) => {
    // Resolve Enum references to their declared value.
    if (value instanceof EnumValue) {
      value = value.resolved;
    }

    if (typeof key !== 'string') {
      throw createValueHasWrongTypeError(
          hostExpr, key,
          `Decorator host metadata must be a string -> string object, but found unparseable key`);
    }

    if (typeof value == 'string') {
      hostMetadata[key] = value;
    } else if (value instanceof DynamicValue) {
      hostMetadata[key] = new WrappedNodeExpr(value.node as ts.Expression);
    } else {
      throw createValueHasWrongTypeError(
          hostExpr, value,
          `Decorator host metadata must be a string -> string object, but found unparseable value`);
    }
  });

  const bindings = parseHostBindings(hostMetadata);

  const errors = verifyHostBindings(bindings, createSourceSpan(hostExpr));
  if (errors.length > 0) {
    throw new FatalDiagnosticError(
        // TODO: provide more granular diagnostic and output specific host expression that
        // triggered an error instead of the whole host object.
        ErrorCode.HOST_BINDING_PARSE_ERROR, hostExpr,
        errors.map((error: ParseError) => error.msg).join('\n'));
  }

  return bindings;
}

/**
 * Extracts and prepares the host directives metadata from an array literal expression.
 * @param rawHostDirectives Expression that defined the `hostDirectives`.
 */
function extractHostDirectives(
    rawHostDirectives: ts.Expression, evaluator: PartialEvaluator,
    compilationMode: CompilationMode): HostDirectiveMeta[] {
  const resolved = evaluator.evaluate(rawHostDirectives, forwardRefResolver);
  if (!Array.isArray(resolved)) {
    throw createValueHasWrongTypeError(
        rawHostDirectives, resolved, 'hostDirectives must be an array');
  }

  return resolved.map(value => {
    const hostReference = value instanceof Map ? value.get('directive') : value;

    // Diagnostics
    if (compilationMode !== CompilationMode.LOCAL) {
      if (!(hostReference instanceof Reference)) {
        throw createValueHasWrongTypeError(
            rawHostDirectives, hostReference, 'Host directive must be a reference');
      }

      if (!isNamedClassDeclaration(hostReference.node)) {
        throw createValueHasWrongTypeError(
            rawHostDirectives, hostReference, 'Host directive reference must be a class');
      }
    }

    let directive: Reference<ClassDeclaration>|Expression;
    let nameForErrors = (fieldName: string) => '@Directive.hostDirectives';
    if (compilationMode === CompilationMode.LOCAL && hostReference instanceof DynamicValue) {
      // At the moment in local compilation we only support simple array for host directives, i.e.,
      // an array consisting of the directive identifiers. We don't support forward refs or other
      // expressions applied on externally imported directives. The main reason is simplicity, and
      // that almost nobody wants to use host directives this way (e.g., what would be the point of
      // forward ref for imported symbols?!)
      if (!ts.isIdentifier(hostReference.node) &&
          !ts.isPropertyAccessExpression(hostReference.node)) {
        throw new FatalDiagnosticError(
            ErrorCode.LOCAL_COMPILATION_EXPRESSION_FOR_HOST_DIRECTIVE, hostReference.node,
            `In local compilation mode, host directive cannot be an expression. Use an identifier instead`);
      }

      directive = new WrappedNodeExpr(hostReference.node);
    } else if (hostReference instanceof Reference) {
      directive = hostReference as Reference<ClassDeclaration>;
      nameForErrors = (fieldName: string) => `@Directive.hostDirectives.${
          (directive as Reference<ClassDeclaration>).node.name.text}.${fieldName}`;
    } else {
      throw new Error('Impossible state');
    }

    const meta: HostDirectiveMeta = {
      directive,
      isForwardReference: hostReference instanceof Reference && hostReference.synthetic,
      inputs:
          parseHostDirectivesMapping('inputs', value, nameForErrors('input'), rawHostDirectives),
      outputs:
          parseHostDirectivesMapping('outputs', value, nameForErrors('output'), rawHostDirectives),
    };

    return meta;
  });
}

/**
 * Parses the expression that defines the `inputs` or `outputs` of a host directive.
 * @param field Name of the field that is being parsed.
 * @param resolvedValue Evaluated value of the expression that defined the field.
 * @param classReference Reference to the host directive class.
 * @param sourceExpression Expression that the host directive is referenced in.
 */
function parseHostDirectivesMapping(
    field: 'inputs'|'outputs', resolvedValue: ResolvedValue, nameForErrors: string,
    sourceExpression: ts.Expression): {[bindingPropertyName: string]: string}|null {
  if (resolvedValue instanceof Map && resolvedValue.has(field)) {
    const rawInputs = resolvedValue.get(field);

    if (isStringArrayOrDie(rawInputs, nameForErrors, sourceExpression)) {
      return parseMappingStringArray(rawInputs);
    }
  }

  return null;
}

/** Converts the parsed host directive information into metadata. */
function toHostDirectiveMetadata(
    hostDirective: HostDirectiveMeta, context: ts.SourceFile,
    refEmitter: ReferenceEmitter): R3HostDirectiveMetadata {
  let directive: R3Reference;
  if (hostDirective.directive instanceof Reference) {
    directive =
        toR3Reference(hostDirective.directive.node, hostDirective.directive, context, refEmitter);
  } else {
    directive = {
      value: hostDirective.directive,
      type: hostDirective.directive,
    };
  }

  return {
    directive,
    isForwardReference: hostDirective.isForwardReference,
    inputs: hostDirective.inputs || null,
    outputs: hostDirective.outputs || null
  };
}

/** Converts the parsed input information into metadata. */
function toR3InputMetadata(mapping: InputMapping): R3InputMetadata {
  return {
    classPropertyName: mapping.classPropertyName,
    bindingPropertyName: mapping.bindingPropertyName,
    required: mapping.required,
    transformFunction: mapping.transform !== null ? new WrappedNodeExpr(mapping.transform.node) :
                                                    null,
    isSignal: mapping.isSignal,
  };
}