feat(ivy): enable inheritance of factory functions in definitions (#25392)

This commit creates an API for factory functions which allows them
to be inherited from one another. To do so, it differentiates between
the factory function as a wrapper for a constructor and the factory
function in ngInjectableDefs which is determined by a default
provider.

The new form is:

factory: (t?) => new (t || SomeType)(inject(Dep1), inject(Dep2))

The 't' parameter allows for constructor inheritance. A subclass with
no declared constructor inherits its constructor from the superclass.
With the 't' parameter, a subclass can call the superclass' factory
function and use it to create an instance of the subclass.

For @Injectables with configured providers, the factory function is
of the form:

factory: (t?) => t ? constructorInject(t) : provider();

where constructorInject(t) creates an instance of 't' using the
naturally declared constructor of the type, and where provider()
creates an instance of the base type using the special declared
provider on @Injectable.

PR Close #25392

packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts

@@ -38,7 +38,7 @@ export class InjectableDecoratorHandler implements DecoratorHandler<R3Injectable
     return {
       name: 'ngInjectableDef',
       initializer: res.expression,
-      statements: [],
+      statements: res.statements,
       type: res.type,
     };
   }
@@ -56,6 +56,7 @@ function extractInjectableMetadata(
   }
   const name = clazz.name.text;
   const type = new WrappedNodeExpr(clazz.name);
+  const ctorDeps = getConstructorDependencies(clazz, reflector, isCore);
   if (decorator.args === null) {
     throw new Error(`@Injectable must be called`);
   }
@@ -63,8 +64,7 @@ function extractInjectableMetadata(
     return {
       name,
       type,
-      providedIn: new LiteralExpr(null),
-      deps: getConstructorDependencies(clazz, reflector, isCore),
+      providedIn: new LiteralExpr(null), ctorDeps,
     };
   } else if (decorator.args.length === 1) {
     const metaNode = decorator.args[0];
@@ -81,30 +81,49 @@ function extractInjectableMetadata(
     if (meta.has('providedIn')) {
       providedIn = new WrappedNodeExpr(meta.get('providedIn') !);
     }
+
+    let userDeps: R3DependencyMetadata[]|undefined = undefined;
+    if ((meta.has('useClass') || meta.has('useFactory')) && meta.has('deps')) {
+      const depsExpr = meta.get('deps') !;
+      if (!ts.isArrayLiteralExpression(depsExpr)) {
+        throw new Error(`In Ivy, deps metadata must be inline.`);
+      }
+      if (depsExpr.elements.length > 0) {
+        throw new Error(`deps not yet supported`);
+      }
+      userDeps = depsExpr.elements.map(dep => getDep(dep, reflector));
+    }
+
     if (meta.has('useValue')) {
-      return {name, type, providedIn, useValue: new WrappedNodeExpr(meta.get('useValue') !)};
+      return {
+        name,
+        type,
+        ctorDeps,
+        providedIn,
+        useValue: new WrappedNodeExpr(meta.get('useValue') !)
+      };
     } else if (meta.has('useExisting')) {
-      return {name, type, providedIn, useExisting: new WrappedNodeExpr(meta.get('useExisting') !)};
+      return {
+        name,
+        type,
+        ctorDeps,
+        providedIn,
+        useExisting: new WrappedNodeExpr(meta.get('useExisting') !)
+      };
     } else if (meta.has('useClass')) {
-      return {name, type, providedIn, useClass: new WrappedNodeExpr(meta.get('useClass') !)};
+      return {
+        name,
+        type,
+        ctorDeps,
+        providedIn,
+        useClass: new WrappedNodeExpr(meta.get('useClass') !), userDeps
+      };
     } else if (meta.has('useFactory')) {
       // useFactory is special - the 'deps' property must be analyzed.
       const factory = new WrappedNodeExpr(meta.get('useFactory') !);
-      const deps: R3DependencyMetadata[] = [];
-      if (meta.has('deps')) {
-        const depsExpr = meta.get('deps') !;
-        if (!ts.isArrayLiteralExpression(depsExpr)) {
-          throw new Error(`In Ivy, deps metadata must be inline.`);
-        }
-        if (depsExpr.elements.length > 0) {
-          throw new Error(`deps not yet supported`);
-        }
-        deps.push(...depsExpr.elements.map(dep => getDep(dep, reflector)));
-      }
-      return {name, type, providedIn, useFactory: factory, deps};
+      return {name, type, providedIn, useFactory: factory, ctorDeps, userDeps};
     } else {
-      const deps = getConstructorDependencies(clazz, reflector, isCore);
-      return {name, type, providedIn, deps};
+      return {name, type, providedIn, ctorDeps};
     }
   } else {
     throw new Error(`Too many arguments to @Injectable`);

packages/compiler-cli/src/ngtsc/annotations/src/util.ts

@@ -13,10 +13,17 @@ import {Decorator, ReflectionHost} from '../../host';
 import {AbsoluteReference, ImportMode, Reference} from '../../metadata';
 
 export function getConstructorDependencies(
-    clazz: ts.ClassDeclaration, reflector: ReflectionHost,
-    isCore: boolean): R3DependencyMetadata[] {
+    clazz: ts.ClassDeclaration, reflector: ReflectionHost, isCore: boolean): R3DependencyMetadata[]|
+    null {
   const useType: R3DependencyMetadata[] = [];
-  const ctorParams = reflector.getConstructorParameters(clazz) || [];
+  let ctorParams = reflector.getConstructorParameters(clazz);
+  if (ctorParams === null) {
+    if (reflector.hasBaseClass(clazz)) {
+      return null;
+    } else {
+      ctorParams = [];
+    }
+  }
   ctorParams.forEach((param, idx) => {
     let tokenExpr = param.type;
     let optional = false, self = false, skipSelf = false, host = false;