Function compileInjectable

packages/compiler/src/injectable_compiler_2.ts:39–146

(
  meta: R3InjectableMetadata,
  resolveForwardRefs: boolean,
)

}

export function compileInjectable(
  meta: R3InjectableMetadata,
  resolveForwardRefs: boolean,
): R3CompiledExpression {
  let result: {expression: o.Expression; statements: o.Statement[]} | null = null;

  const factoryMeta: R3FactoryMetadata = {
    name: meta.name,
    type: meta.type,
    typeArgumentCount: meta.typeArgumentCount,
    deps: [],
    target: FactoryTarget.Injectable,
  };

  if (meta.useClass !== undefined) {
    // meta.useClass has two modes of operation. Either deps are specified, in which case `new` is
    // used to instantiate the class with dependencies injected, or deps are not specified and
    // the factory of the class is used to instantiate it.
    //
    // A special case exists for useClass: Type where Type is the injectable type itself and no
    // deps are specified, in which case 'useClass' is effectively ignored.

    const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.type.value);
    let deps: R3DependencyMetadata[] | undefined = undefined;
    if (meta.deps !== undefined) {
      deps = meta.deps;
    }

    if (deps !== undefined) {
      // factory: () => new meta.useClass(...deps)
      result = compileFactoryFunction({
        ...factoryMeta,
        delegate: meta.useClass.expression,
        delegateDeps: deps,
        delegateType: R3FactoryDelegateType.Class,
      });
    } else if (useClassOnSelf) {
      result = compileFactoryFunction(factoryMeta);
    } else {
      result = {
        statements: [],
        expression: delegateToFactory(
          meta.type.value as o.WrappedNodeExpr<any>,
          meta.useClass.expression as o.WrappedNodeExpr<any>,
          resolveForwardRefs,
        ),
      };
    }
  } else if (meta.useFactory !== undefined) {
    if (meta.deps !== undefined) {
      result = compileFactoryFunction({
        ...factoryMeta,
        delegate: meta.useFactory,
        delegateDeps: meta.deps || [],
        delegateType: R3FactoryDelegateType.Function,
      });
    } else {
      result = {statements: [], expression: o.arrowFn([], meta.useFactory.callFn([]))};