refactor(core): replace internal usages of InjectFlags (angular#60318)

Replaces all the places where we use `InjectFlags` internally with the `InternalInjectFlags` which has the benefit of being a `const` enum and allowing us to consolidate the flags and object literal eventually.

PR Close angular#60318

Author: crisbeto

packages/core/src/change_detection/change_detector_ref.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {InjectFlags, InternalInjectFlags} from '../di/interface/injector';
+import {InternalInjectFlags} from '../di/interface/injector';
 import {TNode, TNodeType} from '../render3/interfaces/node';
 import {isComponentHost} from '../render3/interfaces/type_checks';
 import {DECLARATION_COMPONENT_VIEW, LView} from '../render3/interfaces/view';
@@ -122,11 +122,12 @@ export abstract class ChangeDetectorRef {
    * @internal
    * @nocollapse
    */
-  static __NG_ELEMENT_ID__: (flags: InjectFlags) => ChangeDetectorRef = injectChangeDetectorRef;
+  static __NG_ELEMENT_ID__: (flags: InternalInjectFlags) => ChangeDetectorRef =
+    injectChangeDetectorRef;
 }
 
 /** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */
-export function injectChangeDetectorRef(flags: InjectFlags): ChangeDetectorRef {
+export function injectChangeDetectorRef(flags: InternalInjectFlags): ChangeDetectorRef {
   return createViewRef(
     getCurrentTNode()!,
     getLView(),

packages/core/src/di/host_tag_name_token.ts

@@ -11,7 +11,7 @@ import {TNode, TNodeType} from '../render3/interfaces/node';
 import {getCurrentTNode} from '../render3/state';
 
 import {InjectionToken} from './injection_token';
-import {InjectFlags} from './interface/injector';
+import {InternalInjectFlags} from './interface/injector';
 
 /**
  * A token that can be used to inject the tag name of the host node.
@@ -39,7 +39,7 @@ export const HOST_TAG_NAME = new InjectionToken<string>(ngDevMode ? 'HOST_TAG_NA
 // HOST_TAG_NAME should be resolved at the current node, similar to e.g. ElementRef,
 // so we manually specify __NG_ELEMENT_ID__ here, instead of using a factory.
 // tslint:disable-next-line:no-toplevel-property-access
-(HOST_TAG_NAME as any).__NG_ELEMENT_ID__ = (flags: InjectFlags) => {
+(HOST_TAG_NAME as any).__NG_ELEMENT_ID__ = (flags: InternalInjectFlags) => {
   const tNode = getCurrentTNode();
   if (tNode === null) {
     throw new RuntimeError(
@@ -52,7 +52,7 @@ export const HOST_TAG_NAME = new InjectionToken<string>(ngDevMode ? 'HOST_TAG_NA
   if (tNode.type & TNodeType.Element) {
     return tNode.value;
   }
-  if (flags & InjectFlags.Optional) {
+  if (flags & InternalInjectFlags.Optional) {
     return null;
   }
   throw new RuntimeError(

packages/core/src/di/inject_switch.ts

@@ -8,10 +8,9 @@
 
 import {throwProviderNotFoundError} from '../render3/errors_di';
 import {assertNotEqual} from '../util/assert';
-import {stringify} from '../util/stringify';
 
 import {getInjectableDef, ɵɵInjectableDeclaration} from './interface/defs';
-import {InjectFlags} from './interface/injector';
+import {InternalInjectFlags} from './interface/injector';
 import {ProviderToken} from './provider_token';
 
 /**
@@ -24,7 +23,7 @@ import {ProviderToken} from './provider_token';
  *  2. To maintain tree shake-ability we don't want to bring in unnecessary code.
  */
 let _injectImplementation:
-  | (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null)
+  | (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null)
   | undefined;
 export function getInjectImplementation() {
   return _injectImplementation;
@@ -34,8 +33,8 @@ export function getInjectImplementation() {
  * Sets the current inject implementation.
  */
 export function setInjectImplementation(
-  impl: (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined,
-): (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined {
+  impl: (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined,
+): (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined {
   const previous = _injectImplementation;
   _injectImplementation = impl;
   return previous;
@@ -51,15 +50,15 @@ export function setInjectImplementation(
 export function injectRootLimpMode<T>(
   token: ProviderToken<T>,
   notFoundValue: T | undefined,
-  flags: InjectFlags,
+  flags: InternalInjectFlags,
 ): T | null {
   const injectableDef: ɵɵInjectableDeclaration<T> | null = getInjectableDef(token);
   if (injectableDef && injectableDef.providedIn == 'root') {
     return injectableDef.value === undefined
       ? (injectableDef.value = injectableDef.factory())
       : injectableDef.value;
   }
-  if (flags & InjectFlags.Optional) return null;
+  if (flags & InternalInjectFlags.Optional) return null;
   if (notFoundValue !== undefined) return notFoundValue;
   throwProviderNotFoundError(token, 'Injector');
 }
@@ -72,7 +71,7 @@ export function injectRootLimpMode<T>(
  * @param fn Function which it should not equal to
  */
 export function assertInjectImplementationNotEqual(
-  fn: <T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null,
+  fn: <T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null,
 ) {
   ngDevMode &&
     assertNotEqual(_injectImplementation, fn, 'Calling ɵɵinject would cause infinite recursion');

packages/core/src/di/injector_compatibility.ts

@@ -16,12 +16,7 @@ import {stringify} from '../util/stringify';
 import {resolveForwardRef} from './forward_ref';
 import {getInjectImplementation, injectRootLimpMode} from './inject_switch';
 import type {Injector} from './injector';
-import {
-  DecoratorFlags,
-  InjectFlags,
-  InjectOptions,
-  InternalInjectFlags,
-} from './interface/injector';
+import {DecoratorFlags, InternalInjectFlags, InjectOptions} from './interface/injector';
 import {ProviderToken} from './provider_token';
 import type {HostAttributeToken} from './host_attribute_token';
 import {
@@ -52,12 +47,12 @@ const DI_DECORATOR_FLAG = '__NG_DI_FLAG__';
 export class RetrievingInjector implements PrimitivesInjector {
   constructor(readonly injector: Injector) {}
   retrieve<T>(token: PrimitivesInjectionToken<T>, options: unknown): T | NotFound {
-    const flags: InjectFlags =
-      convertToBitFlags(options as InjectOptions | undefined) || InjectFlags.Default;
+    const flags: InternalInjectFlags =
+      convertToBitFlags(options as InjectOptions | undefined) || InternalInjectFlags.Default;
     return (this.injector as BackwardsCompatibleInjector).get(
       token as unknown as InjectionToken<T>,
       // When a dependency is requested with an optional flag, DI returns null as the default value.
-      flags & InjectFlags.Optional ? null : undefined,
+      flags & InternalInjectFlags.Optional ? null : undefined,
       flags,
     ) as T;
   }
@@ -74,14 +69,21 @@ export const SOURCE = '__source';
  * removed once we consolidate the flags and the object literal approach.
  */
 export type BackwardsCompatibleInjector = Injector & {
-  get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectFlags | InjectOptions): T;
+  get<T>(
+    token: ProviderToken<T>,
+    notFoundValue?: T,
+    options?: InternalInjectFlags | InjectOptions,
+  ): T;
 };
 
 export function injectInjectorOnly<T>(token: ProviderToken<T>): T;
-export function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
 export function injectInjectorOnly<T>(
   token: ProviderToken<T>,
-  flags = InjectFlags.Default,
+  flags?: InternalInjectFlags,
+): T | null;
+export function injectInjectorOnly<T>(
+  token: ProviderToken<T>,
+  flags = InternalInjectFlags.Default,
 ): T | null {
   const currentInjector = getCurrentInjector();
   if (currentInjector === undefined) {
@@ -113,16 +115,16 @@ export function injectInjectorOnly<T>(
  * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
  */
 export function ɵɵinject<T>(token: ProviderToken<T>): T;
-export function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
+export function ɵɵinject<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): T | null;
 export function ɵɵinject(token: HostAttributeToken): string;
-export function ɵɵinject(token: HostAttributeToken, flags?: InjectFlags): string | null;
+export function ɵɵinject(token: HostAttributeToken, flags?: InternalInjectFlags): string | null;
 export function ɵɵinject<T>(
   token: ProviderToken<T> | HostAttributeToken,
-  flags?: InjectFlags,
+  flags?: InternalInjectFlags,
 ): string | null;
 export function ɵɵinject<T>(
   token: ProviderToken<T> | HostAttributeToken,
-  flags = InjectFlags.Default,
+  flags = InternalInjectFlags.Default,
 ): T | null {
   return (getInjectImplementation() || injectInjectorOnly)(
     resolveForwardRef(token as Type<T>),
@@ -279,8 +281,8 @@ export function inject<T>(token: ProviderToken<T> | HostAttributeToken, options?
 
 // Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).
 export function convertToBitFlags(
-  flags: InjectOptions | InjectFlags | undefined,
-): InjectFlags | undefined {
+  flags: InjectOptions | InternalInjectFlags | undefined,
+): InternalInjectFlags | undefined {
   if (typeof flags === 'undefined' || typeof flags === 'number') {
     return flags;
   }
@@ -292,11 +294,11 @@ export function convertToBitFlags(
     ((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;
+    ((flags.skipSelf && InternalInjectFlags.SkipSelf) as number)) as InternalInjectFlags;
 }
 
 // Converts bitflags to inject options
-function convertToInjectOptions(flags: InjectFlags): InjectOptions {
+function convertToInjectOptions(flags: InternalInjectFlags): InjectOptions {
   return {
     optional: !!(flags & InternalInjectFlags.Optional),
     host: !!(flags & InternalInjectFlags.Host),
@@ -317,7 +319,7 @@ export function injectArgs(types: (ProviderToken<any> | any[])[]): any[] {
         );
       }
       let type: Type<any> | undefined = undefined;
-      let flags: InjectFlags = InjectFlags.Default;
+      let flags: InternalInjectFlags = InternalInjectFlags.Default;
 
       for (let j = 0; j < arg.length; j++) {
         const meta = arg[j];

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

@@ -15,35 +15,6 @@ export const enum DecoratorFlags {
   Inject = -1,
 }
 
-/**
- * Injection flags for DI.
- *
- * @publicApi
- * @deprecated use an options object for [`inject`](api/core/inject) instead.
- */
-export enum InjectFlags {
-  // TODO(alxhub): make this 'const' (and remove `InternalInjectFlags` enum) when ngc no longer
-  // writes exports of it into ngfactory files.
-
-  /** Check self and check parent injector if needed */
-  Default = 0b0000,
-
-  /**
-   * Specifies that an injector should retrieve a dependency from any injector until reaching the
-   * host element of the current component. (Only used with Element Injector)
-   */
-  Host = 0b0001,
-
-  /** Don't ascend to ancestors of the node requesting injection. */
-  Self = 0b0010,
-
-  /** Skip the node that is requesting injection. */
-  SkipSelf = 0b0100,
-
-  /** Inject `defaultValue` instead if token not found. */
-  Optional = 0b1000,
-}
-
 /**
  * This enum is an exact copy of the `InjectFlags` enum above, but the difference is that this is a
  * const enum, so actual enum values would be inlined in generated code. The `InjectFlags` enum can

packages/core/src/di/r3_injector.ts

@@ -52,7 +52,7 @@ import {
   InjectorType,
   ɵɵInjectableDeclaration,
 } from './interface/defs';
-import {InjectFlags, InjectOptions} from './interface/injector';
+import {InternalInjectFlags, InjectOptions} from './interface/injector';
 import {
   ClassProvider,
   ConstructorProvider,
@@ -236,12 +236,12 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
   }
 
   retrieve<T>(token: PrimitivesInjectionToken<T>, options?: unknown): T | NotFound {
-    const flags: InjectFlags =
-      convertToBitFlags(options as InjectOptions | undefined) || InjectFlags.Default;
+    const flags: InternalInjectFlags =
+      convertToBitFlags(options as InjectOptions | undefined) || InternalInjectFlags.Default;
     return (this as BackwardsCompatibleInjector).get(
       token as unknown as InjectionToken<T>,
       // When a dependency is requested with an optional flag, DI returns null as the default value.
-      flags & InjectFlags.Optional ? null : undefined,
+      flags & InternalInjectFlags.Optional ? null : undefined,
       flags,
     )!;
   }
@@ -316,7 +316,7 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
       return (token as any)[NG_ENV_ID](this);
     }
 
-    const flags = convertToBitFlags(options) as InjectFlags;
+    const flags = convertToBitFlags(options) as InternalInjectFlags;
 
     // Set the injection context.
     let prevInjectContext: InjectorProfilerContext;
@@ -327,7 +327,7 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
     const previousInjectImplementation = setInjectImplementation(undefined);
     try {
       // Check for the SkipSelf flag.
-      if (!(flags & InjectFlags.SkipSelf)) {
+      if (!(flags & InternalInjectFlags.SkipSelf)) {
         // SkipSelf isn't set, check if the record belongs to this injector.
         let record: Record<T> | undefined | null = this.records.get(token);
         if (record === undefined) {
@@ -358,11 +358,13 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
 
       // Select the next injector based on the Self flag - if self is set, the next injector is
       // the NullInjector, otherwise it's the parent.
-      const nextInjector = !(flags & InjectFlags.Self) ? this.parent : getNullInjector();
+      const nextInjector = !(flags & InternalInjectFlags.Self) ? this.parent : getNullInjector();
       // Set the notFoundValue based on the Optional flag - if optional is set and notFoundValue
       // is undefined, the value is null, otherwise it's the notFoundValue.
       notFoundValue =
-        flags & InjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
+        flags & InternalInjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND
+          ? null
+          : notFoundValue;
       return nextInjector.get(token, notFoundValue);
     } catch (e: any) {
       if (e.name === 'NullInjectorError') {

packages/core/src/render3/debug/injector_profiler.ts

@@ -10,7 +10,7 @@ import type {FactoryProvider, ProviderToken} from '../../di';
 import {resolveForwardRef} from '../../di/forward_ref';
 import {InjectionToken} from '../../di/injection_token';
 import type {Injector} from '../../di/injector';
-import {InjectFlags, InjectOptions, InternalInjectFlags} from '../../di/interface/injector';
+import {InjectOptions, InternalInjectFlags} from '../../di/interface/injector';
 import type {SingleProvider} from '../../di/provider_collection';
 import {Type} from '../../interface/type';
 import {throwError} from '../../util/assert';
@@ -163,7 +163,7 @@ export interface InjectedService {
   /**
    * Flags that this service was injected with
    */
-  flags?: InternalInjectFlags | InjectFlags | InjectOptions;
+  flags?: InternalInjectFlags | InjectOptions;
 
   /**
    * Injector that this service was provided in.
@@ -303,7 +303,11 @@ export function emitInstanceCreatedByInjectorEvent(instance: unknown): void {
  * @param value the instance of the injected service (i.e the result of `inject(token)`)
  * @param flags the flags that the token was injected with
  */
-export function emitInjectEvent(token: Type<unknown>, value: unknown, flags: InjectFlags): void {
+export function emitInjectEvent(
+  token: Type<unknown>,
+  value: unknown,
+  flags: InternalInjectFlags,
+): void {
   !ngDevMode && throwError('Injector profiler should never be called in production mode');
 
   injectorProfiler({