fix(core): missing useExisting providers throwing for optional calls (angular#61137)

Fixes that the runtime was throwing a DI error when attempting to inject a missing `useExisting` provider, despite the call being optional.

The problem was that when the provider has `useExisting`, we do a second `inject` call under the hood which didn't include the inject flags from the original call.

Fixes angular#61121.

PR Close angular#61137

Author: crisbeto

packages/core/src/di/r3_injector.ts

@@ -114,7 +114,7 @@ export function getNullInjector(): Injector {
  * current value.
  */
 interface Record<T> {
-  factory: (() => T) | undefined;
+  factory: ((_: undefined, flags?: InternalInjectFlags) => T) | undefined;
   value: T | {};
   multi: any[] | undefined;
 }
@@ -360,7 +360,7 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
         }
         // If a record was found, get the instance for it and return it.
         if (record != null /* NOT null || undefined */) {
-          return this.hydrate(token, record);
+          return this.hydrate(token, record, flags);
         }
       }
 
@@ -492,7 +492,7 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
     this.records.set(token, record);
   }
 
-  private hydrate<T>(token: ProviderToken<T>, record: Record<T>): T {
+  private hydrate<T>(token: ProviderToken<T>, record: Record<T>, flags: InternalInjectFlags): T {
     const prevConsumer = setActiveConsumer(null);
     try {
       if (record.value === CIRCULAR) {
@@ -503,11 +503,11 @@ export class R3Injector extends EnvironmentInjector implements PrimitivesInjecto
         if (ngDevMode) {
           runInInjectorProfilerContext(this, token as Type<T>, () => {
             emitInjectorToCreateInstanceEvent(token);
-            record.value = record.factory!();
+            record.value = record.factory!(undefined, flags);
             emitInstanceCreatedByInjectorEvent(record.value);
           });
         } else {
-          record.value = record.factory!();
+          record.value = record.factory!(undefined, flags);
         }
       }
       if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {
@@ -596,7 +596,8 @@ function providerToRecord(provider: SingleProvider): Record<any> {
   if (isValueProvider(provider)) {
     return makeRecord(undefined, provider.useValue);
   } else {
-    const factory: (() => any) | undefined = providerToFactory(provider);
+    const factory: ((type?: Type<unknown>, flags?: InternalInjectFlags) => any) | undefined =
+      providerToFactory(provider);
     return makeRecord(factory, NOT_YET);
   }
 }
@@ -610,8 +611,8 @@ export function providerToFactory(
   provider: SingleProvider,
   ngModuleType?: InjectorType<any>,
   providers?: any[],
-): () => any {
-  let factory: (() => any) | undefined = undefined;
+): (type?: Type<unknown>, flags?: number) => any {
+  let factory: ((type?: Type<unknown>, flags?: InternalInjectFlags) => any) | undefined = undefined;
   if (ngDevMode && isEnvironmentProviders(provider)) {
     throwInvalidProviderError(undefined, providers, provider);
   }
@@ -625,7 +626,13 @@ export function providerToFactory(
     } else if (isFactoryProvider(provider)) {
       factory = () => provider.useFactory(...injectArgs(provider.deps || []));
     } else if (isExistingProvider(provider)) {
-      factory = () => ɵɵinject(resolveForwardRef(provider.useExisting));
+      factory = (_, flags) =>
+        ɵɵinject(
+          resolveForwardRef(provider.useExisting),
+          flags !== undefined && flags & InternalInjectFlags.Optional
+            ? InternalInjectFlags.Optional
+            : undefined,
+        );
     } else {
       const classRef = resolveForwardRef(
         provider &&

packages/core/src/render3/di.ts

@@ -662,7 +662,7 @@ function searchTokensOnInjector<T>(
     isHostSpecialCase,
   );
   if (injectableIdx !== null) {
-    return getNodeInjectable(lView, currentTView, injectableIdx, tNode as TElementNode);
+    return getNodeInjectable(lView, currentTView, injectableIdx, tNode as TElementNode, flags);
   } else {
     return NOT_FOUND;
   }
@@ -728,6 +728,7 @@ export function getNodeInjectable(
   tView: TView,
   index: number,
   tNode: TDirectiveHostNode,
+  flags?: InternalInjectFlags,
 ): any {
   let value = lView[index];
   const tData = tView.data;
@@ -765,7 +766,7 @@ export function getNodeInjectable(
     try {
       ngDevMode && emitInjectorToCreateInstanceEvent(token);
 
-      value = lView[index] = factory.factory(undefined, tData, lView, tNode);
+      value = lView[index] = factory.factory(undefined, flags, tData, lView, tNode);
 
       ngDevMode && emitInstanceCreatedByInjectorEvent(value);
 

packages/core/src/render3/di_setup.ts

@@ -7,6 +7,7 @@
  */
 
 import {resolveForwardRef} from '../di/forward_ref';
+import {InternalInjectFlags} from '../di/interface/injector';
 import {ClassProvider, Provider} from '../di/interface/provider';
 import {isClassProvider, isTypeProvider, SingleProvider} from '../di/provider_collection';
 import {providerToFactory} from '../di/r3_injector';
@@ -319,6 +320,7 @@ function indexOf(item: any, arr: any[], begin: number, end: number) {
 function multiProvidersFactoryResolver(
   this: NodeInjectorFactory,
   _: undefined,
+  flags: InternalInjectFlags | undefined,
   tData: TData,
   lData: LView,
   tNode: TDirectiveHostNode,
@@ -334,7 +336,8 @@ function multiProvidersFactoryResolver(
 function multiViewProvidersFactoryResolver(
   this: NodeInjectorFactory,
   _: undefined,
-  tData: TData,
+  _flags: InternalInjectFlags | undefined,
+  _tData: TData,
   lView: LView,
   tNode: TDirectiveHostNode,
 ): any[] {
@@ -382,6 +385,7 @@ function multiFactory(
   factoryFn: (
     this: NodeInjectorFactory,
     _: undefined,
+    flags: InternalInjectFlags | undefined,
     tData: TData,
     lData: LView,
     tNode: TDirectiveHostNode,

packages/core/src/render3/interfaces/injector.ts

@@ -260,6 +260,10 @@ export class NodeInjectorFactory {
     public factory: (
       this: NodeInjectorFactory,
       _: undefined,
+      /**
+       * Flags that control the injection behavior.
+       */
+      flags: InternalInjectFlags | undefined,
       /**
        * array where injectables tokens are stored. This is used in
        * case of an error reporting to produce friendlier errors.

packages/core/test/acceptance/di_spec.ts

@@ -4439,6 +4439,94 @@ describe('di', () => {
     });
   });
 
+  describe('useExisting and optional', () => {
+    const token = new InjectionToken('token');
+    const existing = new InjectionToken('existing');
+
+    it('should return null when injecting a missing useExisting provider with optional: true in a node injector', () => {
+      let value: unknown;
+
+      @Directive({selector: '[dir]'})
+      class Dir {
+        constructor() {
+          value = inject(token, {optional: true});
+        }
+      }
+
+      @Component({
+        template: '<div dir></div>',
+        imports: [Dir],
+        providers: [{provide: token, useExisting: existing}],
+      })
+      class App {}
+
+      TestBed.createComponent(App);
+      expect(value).toBe(null);
+    });
+
+    it('should throw when injecting a missing useExisting provider in a node injector', () => {
+      @Directive({selector: '[dir]'})
+      class Dir {
+        constructor() {
+          inject(token, {optional: false});
+        }
+      }
+
+      @Component({
+        template: '<div dir></div>',
+        imports: [Dir],
+        providers: [{provide: token, useExisting: existing}],
+      })
+      class App {}
+
+      expect(() => TestBed.createComponent(App)).toThrowError(
+        /No provider for InjectionToken existing/,
+      );
+    });
+
+    it('should return null when injecting a missing useExisting provider with optional: true in a module injector', () => {
+      let value: unknown;
+
+      @Directive({selector: '[dir]', standalone: false})
+      class Dir {
+        constructor() {
+          value = inject(token, {optional: true});
+        }
+      }
+
+      @Component({template: '<div dir></div>', standalone: false})
+      class App {}
+
+      TestBed.configureTestingModule({
+        declarations: [App, Dir],
+        providers: [{provide: token, useExisting: existing}],
+      });
+      TestBed.createComponent(App);
+      expect(value).toBe(null);
+    });
+
+    it('should throw when injecting a missing useExisting provider in a module injector', () => {
+      @Directive({selector: '[dir]', standalone: false})
+      class Dir {
+        constructor() {
+          inject(token);
+        }
+      }
+
+      @Component({template: '<div dir></div>', standalone: false})
+      class App {}
+
+      TestBed.configureTestingModule({
+        declarations: [App, Dir],
+        providers: [{provide: token, useExisting: existing}],
+      });
+
+      expect(() => TestBed.createComponent(App)).toThrowError(
+        /No provider for InjectionToken existing/,
+      );
+    });
+  });
+
   it('should be able to use Host in `useFactory` dependency config', () => {
     // Scenario:
     // ---------