Function delegateToFactory

packages/compiler/src/injectable_compiler_2.ts:154–183

(
  type: o.WrappedNodeExpr<any>,
  useType: o.WrappedNodeExpr<any>,
  unwrapForwardRefs: boolean,
)

}

export function delegateToFactory(
  type: o.WrappedNodeExpr<any>,
  useType: o.WrappedNodeExpr<any>,
  unwrapForwardRefs: boolean,
): o.Expression {
  if (type.node === useType.node) {
    // The types are the same, so we can simply delegate directly to the type's factory.
    // ```
    // factory: type.ɵfac
    // ```
    return useType.prop('ɵfac');
  }

  if (!unwrapForwardRefs) {
    // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that
    // accepts a sub-type as an argument.
    // ```
    // factory: function(t) { return useType.ɵfac(t); }
    // ```
    return createFactoryFunction(useType);
  }

  // The useType is actually wrapped in a `forwardRef()` so we need to resolve that before
  // calling its factory.
  // ```
  // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }
  // ```
  const unwrappedType = o.importExpr(Identifiers.resolveForwardRef).callFn([useType]);
  return createFactoryFunction(unwrappedType);
}

function createFactoryFunction(type: o.Expression): o.ArrowFunctionExpr {
  const t = new o.FnParam('__ngFactoryType__', o.DYNAMIC_TYPE);