refactor(ivy): move directive, component and pipe factories to ngFactoryFn (#31953)

Reworks the compiler to output the factories for directives, components and pipes under a new static field called `ngFactoryFn`, instead of the usual `factory` property in their respective defs. This should eventually allow us to inject any kind of decorated class (e.g. a pipe).

**Note:** these changes are the first part of the refactor and they don't include injectables. I decided to leave injectables for a follow-up PR, because there's some more cases we need to handle when it comes to their factories. Furthermore, directives, components and pipes make up most of the compiler output tests that need to be refactored and it'll make follow-up PRs easier to review if the tests are cleaned up now.

This is part of the larger refactor for FW-1468.

PR Close #31953

packages/core/src/render3/definition.ts

@@ -7,6 +7,7 @@
  */
 
 import '../util/ng_dev_mode';
+
 import {ChangeDetectionStrategy} from '../change_detection/constants';
 import {NG_INJECTABLE_DEF, ɵɵdefineInjectable} from '../di/interface/defs';
 import {Mutable, Type} from '../interface/type';
@@ -15,8 +16,9 @@ import {SchemaMetadata} from '../metadata/schema';
 import {ViewEncapsulation} from '../metadata/view';
 import {noSideEffects} from '../util/closure';
 import {stringify} from '../util/stringify';
+
 import {EMPTY_ARRAY, EMPTY_OBJ} from './empty';
-import {NG_BASE_DEF, NG_COMPONENT_DEF, NG_DIRECTIVE_DEF, NG_LOCALE_ID_DEF, NG_MODULE_DEF, NG_PIPE_DEF} from './fields';
+import {NG_BASE_DEF, NG_COMPONENT_DEF, NG_DIRECTIVE_DEF, NG_FACTORY_DEF, NG_LOCALE_ID_DEF, NG_MODULE_DEF, NG_PIPE_DEF} from './fields';
 import {ComponentDef, ComponentDefFeature, ComponentTemplate, ComponentType, ContentQueriesFunction, DirectiveDef, DirectiveDefFeature, DirectiveType, DirectiveTypesOrFactory, FactoryFn, HostBindingsFunction, PipeDef, PipeType, PipeTypesOrFactory, ViewQueriesFunction, ɵɵBaseDef} from './interfaces/definition';
 // while SelectorFlags is unused here, it's required so that types don't get resolved lazily
 // see: https://github.com/Microsoft/web-build-tools/issues/1050
@@ -49,11 +51,6 @@ export function ɵɵdefineComponent<T>(componentDefinition: {
   /** The selectors that will be used to match nodes to this component. */
   selectors: CssSelectorList;
 
-  /**
-   * Factory method used to create an instance of directive.
-   */
-  factory: FactoryFn<T>;
-
   /**
    * The number of nodes, local refs, and pipes in this component template.
    *
@@ -251,7 +248,7 @@ export function ɵɵdefineComponent<T>(componentDefinition: {
     providersResolver: null,
     consts: componentDefinition.consts,
     vars: componentDefinition.vars,
-    factory: componentDefinition.factory,
+    factory: null,
     template: componentDefinition.template || null !,
     ngContentSelectors: componentDefinition.ngContentSelectors,
     hostBindings: componentDefinition.hostBindings || null,
@@ -300,15 +297,6 @@ export function ɵɵdefineComponent<T>(componentDefinition: {
     def.pipeDefs = pipeTypes ?
         () => (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef) :
         null;
-
-    // Add ngInjectableDef so components are reachable through the module injector by default
-    // (unless it has already been set by the @Injectable decorator). This is mostly to
-    // support injecting components in tests. In real application code, components should
-    // be retrieved through the node injector, so this isn't a problem.
-    if (!type.hasOwnProperty(NG_INJECTABLE_DEF)) {
-      (type as any)[NG_INJECTABLE_DEF] =
-          ɵɵdefineInjectable<T>({token: type, factory: componentDefinition.factory as() => T});
-    }
   }) as never;
 
   return def as never;
@@ -615,11 +603,6 @@ export const ɵɵdefineDirective = ɵɵdefineComponent as any as<T>(directiveDef
   /** The selectors that will be used to match nodes to this directive. */
   selectors: CssSelectorList;
 
-  /**
-   * Factory method used to create an instance of directive.
-   */
-  factory: FactoryFn<T>;
-
   /**
    * A map of input names.
    *
@@ -731,15 +714,13 @@ export function ɵɵdefinePipe<T>(pipeDef: {
   /** Pipe class reference. Needed to extract pipe lifecycle hooks. */
   type: Type<T>,
 
-  /** A factory for creating a pipe instance. */
-  factory: FactoryFn<T>,
-
   /** Whether the pipe is pure. */
   pure?: boolean
 }): never {
   return (<PipeDef<T>>{
+    type: pipeDef.type,
     name: pipeDef.name,
-    factory: pipeDef.factory,
+    factory: null,
     pure: pipeDef.pure !== false,
     onDestroy: pipeDef.type.prototype.ngOnDestroy || null
   }) as never;
@@ -752,25 +733,35 @@ export function ɵɵdefinePipe<T>(pipeDef: {
  */
 
 export function getComponentDef<T>(type: any): ComponentDef<T>|null {
-  return (type as any)[NG_COMPONENT_DEF] || null;
+  return type[NG_COMPONENT_DEF] || null;
 }
 
 export function getDirectiveDef<T>(type: any): DirectiveDef<T>|null {
-  return (type as any)[NG_DIRECTIVE_DEF] || null;
+  return type[NG_DIRECTIVE_DEF] || null;
 }
 
 export function getPipeDef<T>(type: any): PipeDef<T>|null {
-  return (type as any)[NG_PIPE_DEF] || null;
+  return type[NG_PIPE_DEF] || null;
 }
 
 export function getBaseDef<T>(type: any): ɵɵBaseDef<T>|null {
-  return (type as any)[NG_BASE_DEF] || null;
+  return type[NG_BASE_DEF] || null;
+}
+
+export function getFactoryDef<T>(type: any, throwNotFound: true): FactoryFn<T>;
+export function getFactoryDef<T>(type: any): FactoryFn<T>|null;
+export function getFactoryDef<T>(type: any, throwNotFound?: boolean): FactoryFn<T>|null {
+  const factoryFn = type[NG_FACTORY_DEF] || null;
+  if (!factoryFn && throwNotFound === true && ngDevMode) {
+    throw new Error(`Type ${stringify(type)} does not have 'ngFactoryDef' property.`);
+  }
+  return factoryFn;
 }
 
 export function getNgModuleDef<T>(type: any, throwNotFound: true): NgModuleDef<T>;
 export function getNgModuleDef<T>(type: any): NgModuleDef<T>|null;
 export function getNgModuleDef<T>(type: any, throwNotFound?: boolean): NgModuleDef<T>|null {
-  const ngModuleDef = (type as any)[NG_MODULE_DEF] || null;
+  const ngModuleDef = type[NG_MODULE_DEF] || null;
   if (!ngModuleDef && throwNotFound === true) {
     throw new Error(`Type ${stringify(type)} does not have 'ngModuleDef' property.`);
   }