Function compileFactoryFunction

packages/compiler/src/render3/r3_factory.ts:106–220

(meta: R3FactoryMetadata)

 * Construct a factory function expression for the given `R3FactoryMetadata`.
 */
export function compileFactoryFunction(meta: R3FactoryMetadata): R3CompiledExpression {
  const t = o.variable('__ngFactoryType__');
  let baseFactoryVar: o.ReadVarExpr | null = null;

  // The type to instantiate via constructor invocation. If there is no delegated factory, meaning
  // this type is always created by constructor invocation, then this is the type-to-create
  // parameter provided by the user (t) if specified, or the current type if not. If there is a
  // delegated factory (which is used to create the current type) then this is only the type-to-
  // create parameter (t).
  const typeForCtor = !isDelegatedFactoryMetadata(meta)
    ? new o.BinaryOperatorExpr(o.BinaryOperator.Or, t, meta.type.value)
    : t;

  let ctorExpr: o.Expression | null = null;

  // If the factory has invalid dependencies (e.g. trying to inject an interface), we normally mark
  // the `deps` as invalid so we can emit an invalid factory. In some environments we may not
  // be able to determine if the dependency is invalid, because that depends on information in
  // other files. To ensure that cases like that still compile, we need to add a `@ts-ignore`
  // comment which allows the code to compile and then error at runtime. Note that it's important
  // to put the comment on a statement, because it includes a new line which may break `return`
  // statements if the comment is set on the expression.
  const factoryComments =
    meta.deps !== null && meta.deps !== 'invalid' && meta.deps.length > 0
      ? [tsIgnoreComment()]
      : undefined;

  if (meta.deps !== null) {
    // There is a constructor (either explicitly or implicitly defined).
    if (meta.deps !== 'invalid') {
      ctorExpr = new o.InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
    }
  } else {
    // There is no constructor, use the base class' factory to construct typeForCtor.
    baseFactoryVar = o.variable(`ɵ${meta.name}_BaseFactory`);
    ctorExpr = baseFactoryVar.callFn([typeForCtor]);
  }

  const body: o.Statement[] = [];
  let retExpr: o.Expression | null = null;

  function makeConditionalFactory(nonCtorExpr: o.Expression): o.ReadVarExpr {
    const r = o.variable('__ngConditionalFactory__');
    body.push(new o.DeclareVarStmt(r.name, o.NULL_EXPR, o.DYNAMIC_TYPE));
    const ctorStmt =
      ctorExpr !== null
        ? r.set(ctorExpr).toStmt(factoryComments)
        : o.importExpr(R3.invalidFactory).callFn([]).toStmt();
    // Always add a `ts-ignore` on the alternate factory.
    body.push(o.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt([tsIgnoreComment()])]));
    return r;
  }

  if (isDelegatedFactoryMetadata(meta)) {
    // This type is created with a delegated factory. If a type parameter is not specified, call
    // the factory instead.
    const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);
    // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.