angular · llorenspujol · Nov 5, 2020
diff --git a/goldens/public-api/forms/forms.d.ts b/goldens/public-api/forms/forms.d.ts
@@ -100,6 +100,8 @@ export declare class AbstractFormGroupDirective extends ControlContainer impleme
    get control(): FormGroup;
    get formDirective(): Form | null;
    get path(): string[];
+    get refCount(): number;
+    addRef(): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
 }

diff --git a/packages/core/src/di/r3_injector.ts b/packages/core/src/di/r3_injector.ts
@@ -542,7 +542,7 @@ function isExistingProvider(value: SingleProvider): value is ExistingProvider {
  return !!(value && (value as ExistingProvider).useExisting);
 }

-function isFactoryProvider(value: SingleProvider): value is FactoryProvider {
+export function isFactoryProvider(value: SingleProvider): value is FactoryProvider {
  return !!(value && (value as FactoryProvider).useFactory);
 }


diff --git a/packages/core/src/render3/di_setup.ts b/packages/core/src/render3/di_setup.ts
@@ -8,8 +8,8 @@


 import {resolveForwardRef} from '../di/forward_ref';
-import {ClassProvider, Provider} from '../di/interface/provider';
-import {isClassProvider, isTypeProvider, providerToFactory} from '../di/r3_injector';
+import {ClassProvider, Provider, TypeProvider} from '../di/interface/provider';
+import {isClassProvider, isFactoryProvider, isTypeProvider, providerToFactory} from '../di/r3_injector';
 import {assertDefined} from '../util/assert';

 import {diPublicInInjector, getNodeInjectable, getOrCreateNodeInjectorForNode} from './di';
@@ -179,6 +179,18 @@ function resolveProvider(
  }
 }

+/**
+ * Function is used as a destroy hook for Factory Providers. This function is invoked in a context
+ * of a provider instance, checks whether there is an `ngOnDestroy` function and invokes it if it's
+ * present.
+ */
+function ngOnDestroyForFactoryProviders(this: any) {
+  const onDestroy = this && this.ngOnDestroy;
+  if (onDestroy) {
+    onDestroy.call(this);
+  }
+}
+
 /**
 * Registers the `ngOnDestroy` hook of a provider, if the provider supports destroy hooks.
 * @param tView `TView` in which to register the hook.
@@ -190,27 +202,36 @@ function resolveProvider(
 function registerDestroyHooksIfSupported(
    tView: TView, provider: Exclude<Provider, any[]>, contextIndex: number,
    indexInFactory?: number) {
-  const providerIsTypeProvider = isTypeProvider(provider);
-  if (providerIsTypeProvider || isClassProvider(provider)) {
-    const prototype = ((provider as ClassProvider).useClass || provider).prototype;
-    const ngOnDestroy = prototype.ngOnDestroy;
-    if (ngOnDestroy) {
-      const hooks = tView.destroyHooks || (tView.destroyHooks = []);
+  let providerIsClassProvider = false;
+  let ngOnDestroy;
+  if (isTypeProvider(provider)) {
+    ngOnDestroy = (provider as TypeProvider).prototype.ngOnDestroy;
+  } else if (isClassProvider(provider)) {
+    providerIsClassProvider = true;
+    ngOnDestroy = (provider as ClassProvider).useClass.prototype.ngOnDestroy;
+  } else if (isFactoryProvider(provider)) {
+    // For factory providers, since we do not have a way to identify whether there is an
+    // `ngOnDestroy` hook before calling a factory function, we register a special function
+    // that would be invoked at destroy time and check whether `ngOnDestroy` is present on a
+    // provider instance (and call the function if it exists).
+    ngOnDestroy = ngOnDestroyForFactoryProviders;
+  }
+  if (ngOnDestroy) {
+    const hooks = tView.destroyHooks || (tView.destroyHooks = []);

-      if (!providerIsTypeProvider && ((provider as ClassProvider)).multi) {
-        ngDevMode &&
-            assertDefined(
-                indexInFactory, 'indexInFactory when registering multi factory destroy hook');
-        const existingCallbacksIndex = hooks.indexOf(contextIndex);
+    if (providerIsClassProvider && ((provider as ClassProvider)).multi) {
+      ngDevMode &&
+          assertDefined(
+              indexInFactory, 'indexInFactory when registering multi factory destroy hook');
+      const existingCallbacksIndex = hooks.indexOf(contextIndex);

-        if (existingCallbacksIndex === -1) {
-          hooks.push(contextIndex, [indexInFactory, ngOnDestroy]);
-        } else {
-          (hooks[existingCallbacksIndex + 1] as DestroyHookData).push(indexInFactory!, ngOnDestroy);
-        }
+      if (existingCallbacksIndex === -1) {
+        hooks.push(contextIndex, [indexInFactory, ngOnDestroy]);
      } else {
-        hooks.push(contextIndex, ngOnDestroy);
+        (hooks[existingCallbacksIndex + 1] as DestroyHookData).push(indexInFactory!, ngOnDestroy);
      }
+    } else {
+      hooks.push(contextIndex, ngOnDestroy);
    }
  }
 }

diff --git a/packages/core/src/view/provider.ts b/packages/core/src/view/provider.ts
@@ -256,8 +256,24 @@ function _createProviderInstance(view: ViewData, def: NodeDef): any {
      return createClass(
          view, def.parent!, allowPrivateServices, providerDef!.value, providerDef!.deps);
    case NodeFlags.TypeFactoryProvider:
-      return callFactory(
+      let injectable: any;
+      injectable = callFactory(
          view, def.parent!, allowPrivateServices, providerDef!.value, providerDef!.deps);
+      // Update def flags if factory injectable has ngOnDestroy function.
+      if (injectable != null && typeof injectable === 'object' &&
+          !(def.flags & NodeFlags.OnDestroy) && typeof injectable.ngOnDestroy === 'function') {
+        def.flags |= NodeFlags.OnDestroy;
+        view.def.nodeFlags |= NodeFlags.OnDestroy;
+        let parent: NodeDef|null = def.parent;
+        if (parent) {
+          parent.directChildFlags |= NodeFlags.OnDestroy;
+          while (parent !== null && !(parent.childFlags & NodeFlags.OnDestroy)) {
+            parent.childFlags |= NodeFlags.OnDestroy;
+            parent = parent.parent;
+          }
+        }
+      }
+      return injectable;
    case NodeFlags.TypeUseExistingProvider:
      return resolveDep(view, def.parent!, allowPrivateServices, providerDef!.deps[0]);
    case NodeFlags.TypeValueProvider:
@@ -573,6 +589,9 @@ function callProviderLifecycles(
    provider.ngAfterViewChecked();
  }
  if (lifecycles & NodeFlags.OnDestroy) {
-    provider.ngOnDestroy();
+    const onDestroy = provider && provider.ngOnDestroy;
+    if (onDestroy) {
+      onDestroy.call(provider);
+    }
  }
 }