cargdev/angular
1
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(ivy): prefix all generated instructions (#29692)

Browse Source 
- Updates all instructions to be prefixed with the Greek delta symbol

PR Close #29692
This commit is contained in:
Ben Lesh
2019-04-04 11:41:52 -07:00
committed by Igor Minar
parent db62ccf9eb
commit 138ca5a246
149 changed files with 8266 additions and 7620 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
packages/core/src/di/index.ts
View File

@ -14,11 +14,11 @@
export * from './metadata';
export {InjectFlags} from './interface/injector';
export {defineInjectable, defineInjector, InjectableType, InjectorType} from './interface/defs';
export {ΔdefineInjectable, defineInjectable, ΔdefineInjector, InjectableType, InjectorType} from './interface/defs';
export {forwardRef, resolveForwardRef, ForwardRefFn} from './forward_ref';
export {Injectable, InjectableDecorator, InjectableProvider} from './injectable';
export {INJECTOR, Injector} from './injector';
export {inject} from './injector_compatibility';
export {Δinject, inject} from './injector_compatibility';
export {ReflectiveInjector} from './reflective_injector';
export {StaticProvider, ValueProvider, ConstructorSansProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ClassProvider} from './interface/provider';
export {ResolvedReflectiveFactory, ResolvedReflectiveProvider} from './reflective_provider';

7
packages/core/src/di/injectable.ts
View File

@ -8,7 +8,8 @@
import {Type} from '../interface/type';
import {TypeDecorator, makeDecorator} from '../util/decorators';
import {InjectableDef, InjectableType, defineInjectable, getInjectableDef} from './interface/defs';
import {InjectableType, getInjectableDef, ΔInjectableDef, ΔdefineInjectable} from './interface/defs';
import {ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueSansProvider} from './interface/provider';
import {compileInjectable as render3CompileInjectable} from './jit/injectable';
import {convertInjectableProviderToFactory} from './util';
@ -79,7 +80,7 @@ export const Injectable: InjectableDecorator = makeDecorator(
*
* @publicApi
*/
export interface InjectableType<T> extends Type<T> { ngInjectableDef: InjectableDef<T>; }
export interface InjectableType<T> extends Type<T> { ngInjectableDef: ΔInjectableDef<T>; }
/**
* Supports @Injectable() in JIT mode for Render2.
@ -88,7 +89,7 @@ function render2CompileInjectable(
injectableType: InjectableType<any>,
options: {providedIn?: Type<any>| 'root' | null} & InjectableProvider): void {
if (options && options.providedIn !== undefined && !getInjectableDef(injectableType)) {
injectableType.ngInjectableDef = defineInjectable({
injectableType.ngInjectableDef = ΔdefineInjectable({
providedIn: options.providedIn,
factory: convertInjectableProviderToFactory(injectableType, options),
});

4
packages/core/src/di/injection_token.ts
View File

@ -8,7 +8,7 @@
import {Type} from '../interface/type';
import {defineInjectable} from './interface/defs';
import {ΔdefineInjectable} from './interface/defs';
/**
* Creates a token that can be used in a DI Provider.
@ -67,7 +67,7 @@ export class InjectionToken<T> {
// We are using it to assign `-1` which is used to identify `Injector`.
(this as any).__NG_ELEMENT_ID__ = options;
} else if (options !== undefined) {
this.ngInjectableDef = defineInjectable({
this.ngInjectableDef = ΔdefineInjectable({
providedIn: options.providedIn || 'root',
factory: options.factory,
});

8
packages/core/src/di/injector.ts
View File

@ -11,8 +11,8 @@ import {getClosureSafeProperty} from '../util/property';
import {stringify} from '../util/stringify';
import {resolveForwardRef} from './forward_ref';
import {InjectionToken} from './injection_token';
import {inject} from './injector_compatibility';
import {defineInjectable} from './interface/defs';
import {Δinject} from './injector_compatibility';
import {ΔdefineInjectable} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, ValueProvider} from './interface/provider';
import {Inject, Optional, Self, SkipSelf} from './metadata';
@ -107,9 +107,9 @@ export abstract class Injector {
}
/** @nocollapse */
static ngInjectableDef = defineInjectable({
static ngInjectableDef = ΔdefineInjectable({
providedIn: 'any' as any,
factory: () => inject(INJECTOR),
factory: () => Δinject(INJECTOR),
});
/**

28
packages/core/src/di/injector_compatibility.ts
View File

@ -11,7 +11,7 @@ import {stringify} from '../util/stringify';
import {InjectionToken} from './injection_token';
import {Injector} from './injector';
import {InjectableDef, getInjectableDef} from './interface/defs';
import {getInjectableDef, ΔInjectableDef} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {Inject, Optional, Self, SkipSelf} from './metadata';
@ -69,7 +69,13 @@ export function injectInjectorOnly<T>(
}
/**
* Injects a token from the currently active injector.
* Generated instruction: Injects a token from the currently active injector.
*
* WARNING: This function is meant to be generated by the Ivy compiler, and is not meant for
* developer consumption!
*
* https://github.com/angular/angular/blob/master/packages/core/src/render3/DELTA_INSTRUCTIONS.md
*
* Must be used in the context of a factory function such as one defined for an
* `InjectionToken`. Throws an error if not called from such a context.
*
@ -91,11 +97,17 @@ export function injectInjectorOnly<T>(
*
* @publicApi
*/
export function inject<T>(token: Type<T>| InjectionToken<T>): T;
export function inject<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T|null;
export function inject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags.Default): T|null {
export function Δinject<T>(token: Type<T>| InjectionToken<T>): T;
export function Δinject<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T|null;
export function Δinject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags.Default): T|null {
return (_injectImplementation || injectInjectorOnly)(token, flags);
}
/**
* @deprecated in v8, delete after v10. This API should be used only be generated code, and that
* code should now use Δinject instead.
* @publicApi
*/
export const inject = Δinject;
/**
* Injects `root` tokens in limp mode.
@ -106,7 +118,7 @@ export function inject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags
*/
export function injectRootLimpMode<T>(
token: Type<T>| InjectionToken<T>, notFoundValue: T | undefined, flags: InjectFlags): T|null {
const injectableDef: InjectableDef<T>|null = getInjectableDef(token);
const injectableDef: ΔInjectableDef<T>|null = getInjectableDef(token);
if (injectableDef && injectableDef.providedIn == 'root') {
return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :
injectableDef.value;
@ -142,9 +154,9 @@ export function injectArgs(types: (Type<any>| InjectionToken<any>| any[])[]): an
}
}
args.push(inject(type !, flags));
args.push(Δinject(type !, flags));
} else {
args.push(inject(arg));
args.push(Δinject(arg));
}
}
return args;

27
packages/core/src/di/interface/defs.ts
View File

@ -23,8 +23,10 @@ import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, S
* that the injectable does not belong to any scope.
*
* NOTE: This is a private type and should not be exported
*
* @publicApi
*/
export interface InjectableDef<T> {
export interface ΔInjectableDef<T> {
/**
* Specifies that the given type belongs to a particular injector:
* - `InjectorType` such as `NgModule`,
@ -55,8 +57,10 @@ export interface InjectableDef<T> {
* an import/dependency structure).
*
* NOTE: This is a private type and should not be exported
*
* @publicApi
*/
export interface InjectorDef<T> {
export interface ΔInjectorDef<T> {
factory: () => T;
// TODO(alxhub): Narrow down the type here once decorators properly change the return type of the
@ -127,15 +131,22 @@ export interface InjectorTypeWithProviders<T> {
*
* @publicApi
*/
export function defineInjectable<T>(opts: {
export function ΔdefineInjectable<T>(opts: {
providedIn?: Type<any>| 'root' | 'any' | null,
factory: () => T,
}): never {
return ({
providedIn: opts.providedIn as any || null, factory: opts.factory, value: undefined,
} as InjectableDef<T>) as never;
} as ΔInjectableDef<T>) as never;
}
/**
* @deprecated in v8, delete after v10. This API should be used only be generated code, and that
* code should now use ΔdefineInjectable instead.
* @publicApi
*/
export const defineInjectable = ΔdefineInjectable;
/**
* Construct an `InjectorDef` which configures an injector.
*
@ -156,11 +167,11 @@ export function defineInjectable<T>(opts: {
*
* @publicApi
*/
export function defineInjector(options: {factory: () => any, providers?: any[], imports?: any[]}):
export function ΔdefineInjector(options: {factory: () => any, providers?: any[], imports?: any[]}):
never {
return ({
factory: options.factory, providers: options.providers || [], imports: options.imports || [],
} as InjectorDef<any>) as never;
} as ΔInjectorDef<any>) as never;
}
/**
@ -168,7 +179,7 @@ export function defineInjector(options: {factory: () => any, providers?: any[],
*
* @param type type which may have `ngInjectableDef`
*/
export function getInjectableDef<T>(type: any): InjectableDef<T>|null {
export function getInjectableDef<T>(type: any): ΔInjectableDef<T>|null {
return type && type.hasOwnProperty(NG_INJECTABLE_DEF) ? (type as any)[NG_INJECTABLE_DEF] : null;
}
@ -177,7 +188,7 @@ export function getInjectableDef<T>(type: any): InjectableDef<T>|null {
*
* @param type type which may have `ngInjectorDef`
*/
export function getInjectorDef<T>(type: any): InjectorDef<T>|null {
export function getInjectorDef<T>(type: any): ΔInjectorDef<T>|null {
return type && type.hasOwnProperty(NG_INJECTOR_DEF) ? (type as any)[NG_INJECTOR_DEF] : null;
}

13
packages/core/src/di/jit/environment.ts
View File

@ -7,8 +7,9 @@
*/
import {Type} from '../../interface/type';
import {inject} from '../injector_compatibility';
import {defineInjectable, defineInjector, getInjectableDef, getInjectorDef} from '../interface/defs';
import {Δinject} from '../injector_compatibility';
import {getInjectableDef, getInjectorDef, ΔdefineInjectable, ΔdefineInjector} from '../interface/defs';
/**
@ -17,10 +18,10 @@ import {defineInjectable, defineInjector, getInjectableDef, getInjectorDef} from
* This should be kept up to date with the public exports of @angular/core.
*/
export const angularCoreDiEnv: {[name: string]: Function} = {
'defineInjectable': defineInjectable,
'defineInjector': defineInjector,
'inject': inject,
'ɵgetFactoryOf': getFactoryOf,
'ΔdefineInjectable': ΔdefineInjectable,
'ΔdefineInjector': ΔdefineInjector,
'Δinject': Δinject,
'ΔgetFactoryOf': getFactoryOf,
};
function getFactoryOf<T>(type: Type<any>): ((type: Type<T>| null) => T)|null {

10
packages/core/src/di/r3_injector.ts
View File

@ -9,16 +9,18 @@
import {OnDestroy} from '../interface/lifecycle_hooks';
import {Type} from '../interface/type';
import {stringify} from '../util/stringify';
import {resolveForwardRef} from './forward_ref';
import {InjectionToken} from './injection_token';
import {INJECTOR, Injector, NG_TEMP_TOKEN_PATH, NullInjector, USE_VALUE, catchInjectorError} from './injector';
import {inject, injectArgs, setCurrentInjector} from './injector_compatibility';
import {InjectableDef, InjectableType, InjectorType, InjectorTypeWithProviders, getInjectableDef, getInjectorDef} from './interface/defs';
import {injectArgs, setCurrentInjector, Δinject} from './injector_compatibility';
import {InjectableType, InjectorType, InjectorTypeWithProviders, getInjectableDef, getInjectorDef, ΔInjectableDef} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, TypeProvider, ValueProvider} from './interface/provider';
import {APP_ROOT} from './scope';
/**
* Internal type for a single provider in a deep provider array.
*/
@ -354,7 +356,7 @@ export class R3Injector {
return record.value as T;
}
private injectableDefInScope(def: InjectableDef<any>): boolean {
private injectableDefInScope(def: ΔInjectableDef<any>): boolean {
if (!def.providedIn) {
return false;
} else if (typeof def.providedIn === 'string') {
@ -411,7 +413,7 @@ export function providerToFactory(
if (isValueProvider(provider)) {
factory = () => resolveForwardRef(provider.useValue);
} else if (isExistingProvider(provider)) {
factory = () => inject(resolveForwardRef(provider.useExisting));
factory = () => Δinject(resolveForwardRef(provider.useExisting));
} else if (isFactoryProvider(provider)) {
factory = () => provider.useFactory(...injectArgs(provider.deps || []));
} else {

4
packages/core/src/di/util.ts
View File

@ -10,7 +10,7 @@ import {Type} from '../interface/type';
import {ReflectionCapabilities} from '../reflection/reflection_capabilities';
import {getClosureSafeProperty} from '../util/property';
import {inject, injectArgs} from './injector_compatibility';
import {injectArgs, Δinject} from './injector_compatibility';
import {ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueProvider, ValueSansProvider} from './interface/provider';
const USE_VALUE =
@ -32,7 +32,7 @@ export function convertInjectableProviderToFactory(
return () => valueProvider.useValue;
} else if ((provider as ExistingSansProvider).useExisting) {
const existingProvider = (provider as ExistingSansProvider);
return () => inject(existingProvider.useExisting);
return () => Δinject(existingProvider.useExisting);
} else if ((provider as FactorySansProvider).useFactory) {
const factoryProvider = (provider as FactorySansProvider);
return () => factoryProvider.useFactory(...injectArgs(factoryProvider.deps || EMPTY_ARRAY));