feat(core): support object-based DI flags in Injector.get()

This commit applies the changes similar to the ones performed for the `inject()` function in df246bb.

The `Injector.get` function is updated to use previously added object-based API for options: now the flags argument supports passing an object which configures injection flags.

DEPRECATED:

The bit field signature of `Injector.get()` has been deprecated, in favor of the new options object.

goldens/public-api/core/index.md

@@ -468,6 +468,8 @@ export const ENVIRONMENT_INITIALIZER: InjectionToken<() => void>;
 export abstract class EnvironmentInjector implements Injector {
     // (undocumented)
     abstract destroy(): void;
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
+    // @deprecated
     abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
     // @deprecated (undocumented)
     abstract get(token: any, notFoundValue?: any): any;
@@ -707,6 +709,8 @@ export abstract class Injector {
         parent?: Injector;
         name?: string;
     }): Injector;
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags): T;
+    // @deprecated
     abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
     // @deprecated (undocumented)
     abstract get(token: any, notFoundValue?: any): any;

packages/core/src/di/index.ts

@@ -22,7 +22,8 @@ export {EnvironmentInjector} from './r3_injector';
 export {importProvidersFrom, ImportProvidersSource} from './provider_collection';
 export {ENVIRONMENT_INITIALIZER} from './initializer_token';
 export {ProviderToken} from './provider_token';
-export {ɵɵinject, inject, InjectOptions, ɵɵinvalidFactoryDep} from './injector_compatibility';
+export {ɵɵinject, inject, ɵɵinvalidFactoryDep} from './injector_compatibility';
+export {InjectOptions} from './interface/injector';
 export {INJECTOR} from './injector_token';
 export {ReflectiveInjector} from './reflective_injector';
 export {ClassProvider, ModuleWithProviders, ClassSansProvider, ImportedNgModuleProviders, ConstructorProvider, ConstructorSansProvider, ExistingProvider, ExistingSansProvider, FactoryProvider, FactorySansProvider, Provider, StaticClassProvider, StaticClassSansProvider, StaticProvider, TypeProvider, ValueProvider, ValueSansProvider} from './interface/provider';

packages/core/src/di/injector.ts

@@ -12,7 +12,7 @@ import {THROW_IF_NOT_FOUND, ɵɵinject} from './injector_compatibility';
 import {InjectorMarkers} from './injector_marker';
 import {INJECTOR} from './injector_token';
 import {ɵɵdefineInjectable} from './interface/defs';
-import {InjectFlags} from './interface/injector';
+import {InjectFlags, InjectOptions} from './interface/injector';
 import {StaticProvider} from './interface/provider';
 import {NullInjector} from './null_injector';
 import {ProviderToken} from './provider_token';
@@ -50,6 +50,14 @@ export abstract class Injector {
    * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
    * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
    */
+  abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions|InjectFlags):
+      T;
+  /**
+   * Retrieves an instance from the injector based on the provided token.
+   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+   * @deprecated use object-based flags (`InjectOptions`) instead.
+   */
   abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
   /**
    * @deprecated from v4.0.0 use ProviderToken<T>

packages/core/src/di/injector_compatibility.ts

@@ -15,7 +15,7 @@ import {stringify} from '../util/stringify';
 import {resolveForwardRef} from './forward_ref';
 import {getInjectImplementation, injectRootLimpMode} from './inject_switch';
 import {Injector} from './injector';
-import {DecoratorFlags, InjectFlags, InternalInjectFlags} from './interface/injector';
+import {DecoratorFlags, InjectFlags, InjectOptions, InternalInjectFlags} from './interface/injector';
 import {ProviderToken} from './provider_token';
 
 
@@ -102,35 +102,6 @@ Please check that 1) the type for the parameter at index ${
               index} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`);
 }
 
-/**
- * Type of the options argument to `inject`.
- *
- * @publicApi
- */
-export interface InjectOptions {
-  /**
-   * Use optional injection, and return `null` if the requested token is not found.
-   */
-  optional?: boolean;
-
-  /**
-   * Start injection at the parent of the current injector.
-   */
-  skipSelf?: boolean;
-
-  /**
-   * Only query the current injector for the token, and don't fall back to the parent injector if
-   * it's not found.
-   */
-  self?: boolean;
-
-  /**
-   * Stop injection at the host component's injector. Only relevant when injecting from an element
-   * injector, and a no-op for environment injectors.
-   */
-  host?: boolean;
-}
-
 /**
  * @param token A token that represents a dependency that should be injected.
  * @returns the injected value if operation is successful, `null` otherwise.
@@ -240,17 +211,22 @@ export function inject<T>(token: ProviderToken<T>, options: InjectOptions): T|nu
  */
 export function inject<T>(
     token: ProviderToken<T>, flags: InjectFlags|InjectOptions = InjectFlags.Default): T|null {
-  if (typeof flags !== 'number') {
-    // While TypeScript doesn't accept it without a cast, bitwise OR with false-y values in
-    // JavaScript is a no-op. We can use that for a very codesize-efficient conversion from
-    // `InjectOptions` to `InjectFlags`.
-    flags = (InternalInjectFlags.Default |  // comment to force a line break in the formatter
-             ((flags.optional && InternalInjectFlags.Optional) as number) |
-             ((flags.host && InternalInjectFlags.Host) as number) |
-             ((flags.self && InternalInjectFlags.Self) as number) |
-             ((flags.skipSelf && InternalInjectFlags.SkipSelf) as number)) as InjectFlags;
-  }
-  return ɵɵinject(token, flags);
+  return ɵɵinject(token, convertToBitFlags(flags));
+}
+
+// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).
+export function convertToBitFlags(flags: InjectOptions|InjectFlags|undefined): InjectFlags|
+    undefined {
+  if (typeof flags === 'undefined' || typeof flags === 'number') return flags;
+
+  // While TypeScript doesn't accept it without a cast, bitwise OR with false-y values in
+  // JavaScript is a no-op. We can use that for a very codesize-efficient conversion from
+  // `InjectOptions` to `InjectFlags`.
+  return (InternalInjectFlags.Default |  // comment to force a line break in the formatter
+          ((flags.optional && InternalInjectFlags.Optional) as number) |
+          ((flags.host && InternalInjectFlags.Host) as number) |
+          ((flags.self && InternalInjectFlags.Self) as number) |
+          ((flags.skipSelf && InternalInjectFlags.SkipSelf) as number)) as InjectFlags;
 }
 
 export function injectArgs(types: (ProviderToken<any>|any[])[]): any[] {

packages/core/src/di/interface/injector.ts

@@ -80,3 +80,32 @@ export const enum InternalInjectFlags {
    */
   ForPipe = 0b10000,
 }
+
+/**
+ * Type of the options argument to `inject`.
+ *
+ * @publicApi
+ */
+export interface InjectOptions {
+  /**
+   * Use optional injection, and return `null` if the requested token is not found.
+   */
+  optional?: boolean;
+
+  /**
+   * Start injection at the parent of the current injector.
+   */
+  skipSelf?: boolean;
+
+  /**
+   * Only query the current injector for the token, and don't fall back to the parent injector if
+   * it's not found.
+   */
+  self?: boolean;
+
+  /**
+   * Stop injection at the host component's injector. Only relevant when injecting from an element
+   * injector, and a no-op for environment injectors.
+   */
+  host?: boolean;
+}

packages/core/src/di/r3_injector.ts

@@ -23,14 +23,14 @@ import {ENVIRONMENT_INITIALIZER} from './initializer_token';
 import {setInjectImplementation} from './inject_switch';
 import {InjectionToken} from './injection_token';
 import {Injector} from './injector';
-import {catchInjectorError, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, ɵɵinject} from './injector_compatibility';
+import {catchInjectorError, convertToBitFlags, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, ɵɵinject} from './injector_compatibility';
 import {INJECTOR} from './injector_token';
 import {getInheritedInjectableDef, getInjectableDef, InjectorType, ɵɵInjectableDeclaration} from './interface/defs';
-import {InjectFlags} from './interface/injector';
+import {InjectFlags, InjectOptions} from './interface/injector';
 import {ClassProvider, ConstructorProvider, ImportedNgModuleProviders, Provider, StaticClassProvider} from './interface/provider';
 import {INJECTOR_DEF_TYPES} from './internal_tokens';
 import {NullInjector} from './null_injector';
-import {importProvidersFrom, isExistingProvider, isFactoryProvider, isTypeProvider, isValueProvider, SingleProvider} from './provider_collection';
+import {isExistingProvider, isFactoryProvider, isTypeProvider, isValueProvider, SingleProvider} from './provider_collection';
 import {ProviderToken} from './provider_token';
 import {INJECTOR_SCOPE, InjectorScope} from './scope';
 
@@ -82,6 +82,13 @@ export abstract class EnvironmentInjector implements Injector {
    * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
    * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
    */
+  abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
+  /**
+   * Retrieves an instance from the injector based on the provided token.
+   * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+   * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+   * @deprecated use object-based flags (`InjectOptions`) instead.
+   */
   abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
   /**
    * @deprecated from v4.0.0 use ProviderToken<T>
@@ -207,8 +214,10 @@ export class R3Injector extends EnvironmentInjector {
 
   override get<T>(
       token: ProviderToken<T>, notFoundValue: any = THROW_IF_NOT_FOUND,
-      flags = InjectFlags.Default): T {
+      flags: InjectFlags|InjectOptions = InjectFlags.Default): T {
     this.assertNotDestroyed();
+    flags = convertToBitFlags(flags) as InjectFlags;
+
     // Set the injection context.
     const previousInjector = setCurrentInjector(this);
     const previousInjectImplementation = setInjectImplementation(undefined);

packages/core/src/render3/component_ref.ts

@@ -8,10 +8,11 @@
 
 import {ChangeDetectorRef as ViewEngine_ChangeDetectorRef} from '../change_detection/change_detector_ref';
 import {Injector} from '../di/injector';
-import {InjectFlags} from '../di/interface/injector';
+import {convertToBitFlags} from '../di/injector_compatibility';
+import {InjectFlags, InjectOptions} from '../di/interface/injector';
 import {ProviderToken} from '../di/provider_token';
 import {EnvironmentInjector} from '../di/r3_injector';
-import {formatRuntimeError, RuntimeError, RuntimeErrorCode} from '../errors';
+import {RuntimeError, RuntimeErrorCode} from '../errors';
 import {Type} from '../interface/type';
 import {ComponentFactory as viewEngine_ComponentFactory, ComponentRef as viewEngine_ComponentRef} from '../linker/component_factory';
 import {ComponentFactoryResolver as viewEngine_ComponentFactoryResolver} from '../linker/component_factory_resolver';
@@ -27,7 +28,7 @@ import {createRootComponent, createRootComponentView, createRootContext, Lifecyc
 import {getComponentDef} from './definition';
 import {NodeInjector} from './di';
 import {reportUnknownPropertyError} from './instructions/element_validation';
-import {createLView, createTView, initializeInputAndOutputAliases, locateHostElement, markDirtyIfOnPush, renderView, setInputsForProperty} from './instructions/shared';
+import {createLView, createTView, locateHostElement, markDirtyIfOnPush, renderView, setInputsForProperty} from './instructions/shared';
 import {ComponentDef} from './interfaces/definition';
 import {PropertyAliasValue, TContainerNode, TElementContainerNode, TElementNode, TNode} from './interfaces/node';
 import {RNode} from './interfaces/renderer_dom';
@@ -79,7 +80,8 @@ function getNamespace(elementName: string): string|null {
 class ChainedInjector implements Injector {
   constructor(private injector: Injector, private parentInjector: Injector) {}
 
-  get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T {
+  get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags|InjectOptions): T {
+    flags = convertToBitFlags(flags);
     const value = this.injector.get<T|typeof NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR>(
         token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, flags);
 

packages/core/src/render3/di.ts

@@ -9,8 +9,9 @@
 import {isForwardRef, resolveForwardRef} from '../di/forward_ref';
 import {injectRootLimpMode, setInjectImplementation} from '../di/inject_switch';
 import {Injector} from '../di/injector';
+import {convertToBitFlags} from '../di/injector_compatibility';
 import {InjectorMarkers} from '../di/injector_marker';
-import {InjectFlags} from '../di/interface/injector';
+import {InjectFlags, InjectOptions} from '../di/interface/injector';
 import {ProviderToken} from '../di/provider_token';
 import {Type} from '../interface/type';
 import {assertDefined, assertEqual, assertIndexInRange} from '../util/assert';
@@ -704,8 +705,9 @@ export class NodeInjector implements Injector {
       private _tNode: TElementNode|TContainerNode|TElementContainerNode|null,
       private _lView: LView) {}
 
-  get(token: any, notFoundValue?: any, flags?: InjectFlags): any {
-    return getOrCreateInjectable(this._tNode, this._lView, token, flags, notFoundValue);
+  get(token: any, notFoundValue?: any, flags?: InjectFlags|InjectOptions): any {
+    return getOrCreateInjectable(
+        this._tNode, this._lView, token, convertToBitFlags(flags), notFoundValue);
   }
 }
 

packages/core/src/render3/ng_module_ref.ts

@@ -8,8 +8,9 @@
 
 import {createInjectorWithoutInjectorInstances} from '../di/create_injector';
 import {Injector} from '../di/injector';
+import {convertToBitFlags} from '../di/injector_compatibility';
 import {INJECTOR} from '../di/injector_token';
-import {InjectFlags} from '../di/interface/injector';
+import {InjectFlags, InjectOptions} from '../di/interface/injector';
 import {ImportedNgModuleProviders, Provider} from '../di/interface/provider';
 import {EnvironmentInjector, getNullInjector, R3Injector} from '../di/r3_injector';
 import {Type} from '../interface/type';
@@ -90,11 +91,11 @@ export class NgModuleRef<T> extends viewEngine_NgModuleRef<T> implements Interna
   }
 
   get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND,
-      injectFlags: InjectFlags = InjectFlags.Default): any {
+      injectFlags: InjectFlags|InjectOptions = InjectFlags.Default): any {
     if (token === Injector || token === viewEngine_NgModuleRef || token === INJECTOR) {
       return this;
     }
-    return this._r3Injector.get(token, notFoundValue, injectFlags);
+    return this._r3Injector.get(token, notFoundValue, convertToBitFlags(injectFlags));
   }
 
   runInContext<ReturnT>(fn: () => ReturnT): ReturnT {