feat(ivy): enable inheritance of factory functions in definitions (#25392)
This commit creates an API for factory functions which allows them to be inherited from one another. To do so, it differentiates between the factory function as a wrapper for a constructor and the factory function in ngInjectableDefs which is determined by a default provider. The new form is: factory: (t?) => new (t || SomeType)(inject(Dep1), inject(Dep2)) The 't' parameter allows for constructor inheritance. A subclass with no declared constructor inherits its constructor from the superclass. With the 't' parameter, a subclass can call the superclass' factory function and use it to create an instance of the subclass. For @Injectables with configured providers, the factory function is of the form: factory: (t?) => t ? constructorInject(t) : provider(); where constructorInject(t) creates an instance of 't' using the naturally declared constructor of the type, and where provider() creates an instance of the base type using the special declared provider on @Injectable. PR Close #25392
This commit is contained in:
Alex Rickabaugh
committed by
Ben Lesh
Ben Lesh
parent
fba276d3d1
commit
5be186035f
@ -9,103 +9,103 @@
|
||||
import {InjectFlags} from './core';
|
||||
import {Identifiers} from './identifiers';
|
||||
import * as o from './output/output_ast';
|
||||
import {R3DependencyMetadata, compileFactoryFunction} from './render3/r3_factory';
|
||||
import {R3DependencyMetadata, R3FactoryDelegateType, R3FactoryMetadata, compileFactoryFunction} from './render3/r3_factory';
|
||||
import {mapToMapExpression} from './render3/util';
|
||||
|
||||
export interface InjectableDef {
|
||||
expression: o.Expression;
|
||||
type: o.Type;
|
||||
statements: o.Statement[];
|
||||
}
|
||||
|
||||
export interface R3InjectableMetadata {
|
||||
name: string;
|
||||
type: o.Expression;
|
||||
ctorDeps: R3DependencyMetadata[]|null;
|
||||
providedIn: o.Expression;
|
||||
useClass?: o.Expression;
|
||||
useFactory?: o.Expression;
|
||||
useExisting?: o.Expression;
|
||||
useValue?: o.Expression;
|
||||
deps?: R3DependencyMetadata[];
|
||||
userDeps?: R3DependencyMetadata[];
|
||||
}
|
||||
|
||||
export function compileInjectable(meta: R3InjectableMetadata): InjectableDef {
|
||||
let factory: o.Expression = o.NULL_EXPR;
|
||||
let result: {factory: o.Expression, statements: o.Statement[]}|null = null;
|
||||
|
||||
function makeFn(ret: o.Expression): o.Expression {
|
||||
return o.fn([], [new o.ReturnStatement(ret)], undefined, undefined, `${meta.name}_Factory`);
|
||||
}
|
||||
|
||||
if (meta.useClass !== undefined || meta.useFactory !== undefined) {
|
||||
// First, handle useClass and useFactory together, since both involve a similar call to
|
||||
// `compileFactoryFunction`. Either dependencies are explicitly specified, in which case
|
||||
// a factory function call is generated, or they're not specified and the calls are special-
|
||||
// cased.
|
||||
if (meta.deps !== undefined) {
|
||||
// Either call `new meta.useClass(...)` or `meta.useFactory(...)`.
|
||||
const fnOrClass: o.Expression = meta.useClass || meta.useFactory !;
|
||||
const factoryMeta = {
|
||||
name: meta.name,
|
||||
type: meta.type,
|
||||
deps: meta.ctorDeps,
|
||||
injectFn: Identifiers.inject,
|
||||
};
|
||||
|
||||
// useNew: true if meta.useClass, false for meta.useFactory.
|
||||
const useNew = meta.useClass !== undefined;
|
||||
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, in which
|
||||
// case omitting deps just uses the constructor dependencies instead.
|
||||
|
||||
factory = compileFactoryFunction({
|
||||
name: meta.name,
|
||||
fnOrClass,
|
||||
useNew,
|
||||
injectFn: Identifiers.inject,
|
||||
deps: meta.deps,
|
||||
const useClassOnSelf = meta.useClass.isEquivalent(meta.type);
|
||||
const deps = meta.userDeps || (useClassOnSelf && meta.ctorDeps) || undefined;
|
||||
|
||||
if (deps !== undefined) {
|
||||
// factory: () => new meta.useClass(...deps)
|
||||
result = compileFactoryFunction({
|
||||
...factoryMeta,
|
||||
delegate: meta.useClass,
|
||||
delegateDeps: deps,
|
||||
delegateType: R3FactoryDelegateType.Class,
|
||||
});
|
||||
} else if (meta.useClass !== undefined) {
|
||||
// Special case for useClass where the factory from the class's ngInjectableDef is used.
|
||||
if (meta.useClass.isEquivalent(meta.type)) {
|
||||
// For the injectable compiler, useClass represents a foreign type that should be
|
||||
// instantiated to satisfy construction of the given type. It's not valid to specify
|
||||
// useClass === type, since the useClass type is expected to already be compiled.
|
||||
throw new Error(
|
||||
`useClass is the same as the type, but no deps specified, which is invalid.`);
|
||||
}
|
||||
factory =
|
||||
makeFn(new o.ReadPropExpr(new o.ReadPropExpr(meta.useClass, 'ngInjectableDef'), 'factory')
|
||||
.callFn([]));
|
||||
} else if (meta.useFactory !== undefined) {
|
||||
// Special case for useFactory where no arguments are passed.
|
||||
factory = meta.useFactory.callFn([]);
|
||||
} else {
|
||||
// Can't happen - outer conditional guards against both useClass and useFactory being
|
||||
// undefined.
|
||||
throw new Error('Reached unreachable block in injectable compiler.');
|
||||
result = compileFactoryFunction({
|
||||
...factoryMeta,
|
||||
delegate: meta.useClass,
|
||||
delegateType: R3FactoryDelegateType.Factory,
|
||||
});
|
||||
}
|
||||
} else if (meta.useFactory !== undefined) {
|
||||
result = compileFactoryFunction({
|
||||
...factoryMeta,
|
||||
delegate: meta.useFactory,
|
||||
delegateDeps: meta.userDeps || [],
|
||||
delegateType: R3FactoryDelegateType.Function,
|
||||
});
|
||||
} else if (meta.useValue !== undefined) {
|
||||
// Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for
|
||||
// client code because meta.useValue is an Expression which will be defined even if the actual
|
||||
// value is undefined.
|
||||
factory = makeFn(meta.useValue);
|
||||
result = compileFactoryFunction({
|
||||
...factoryMeta,
|
||||
expression: meta.useValue,
|
||||
});
|
||||
} else if (meta.useExisting !== undefined) {
|
||||
// useExisting is an `inject` call on the existing token.
|
||||
factory = makeFn(o.importExpr(Identifiers.inject).callFn([meta.useExisting]));
|
||||
} else {
|
||||
// A strict type is compiled according to useClass semantics, except the dependencies are
|
||||
// required.
|
||||
if (meta.deps === undefined) {
|
||||
throw new Error(`Type compilation of an injectable requires dependencies.`);
|
||||
}
|
||||
factory = compileFactoryFunction({
|
||||
name: meta.name,
|
||||
fnOrClass: meta.type,
|
||||
useNew: true,
|
||||
injectFn: Identifiers.inject,
|
||||
deps: meta.deps,
|
||||
result = compileFactoryFunction({
|
||||
...factoryMeta,
|
||||
expression: o.importExpr(Identifiers.inject).callFn([meta.useExisting]),
|
||||
});
|
||||
} else {
|
||||
result = compileFactoryFunction(factoryMeta);
|
||||
}
|
||||
|
||||
const token = meta.type;
|
||||
const providedIn = meta.providedIn;
|
||||
|
||||
const expression = o.importExpr(Identifiers.defineInjectable).callFn([mapToMapExpression(
|
||||
{token, factory, providedIn})]);
|
||||
{token, factory: result.factory, providedIn})]);
|
||||
const type = new o.ExpressionType(
|
||||
o.importExpr(Identifiers.InjectableDef, [new o.ExpressionType(meta.type)]));
|
||||
|
||||
return {
|
||||
expression, type,
|
||||
expression,
|
||||
type,
|
||||
statements: result.statements,
|
||||
};
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user