feat(ivy): generate pipe references and definitions (#22034)

PR Close #22034

packages/compiler/src/constant_pool.ts

@@ -11,7 +11,7 @@ import {OutputContext, error} from './util';
 
 const CONSTANT_PREFIX = '_c';
 
-export const enum DefinitionKind {Injector, Directive, Component}
+export const enum DefinitionKind {Injector, Directive, Component, Pipe}
 
 /**
  * A node that is a place-holder that allows the node to be replaced when the actual
@@ -51,6 +51,7 @@ export class ConstantPool {
   private injectorDefinitions = new Map<any, FixupExpression>();
   private directiveDefinitions = new Map<any, FixupExpression>();
   private componentDefinitions = new Map<any, FixupExpression>();
+  private pipeDefinitions = new Map<any, FixupExpression>();
 
   private nextNameIndex = 0;
 
@@ -75,18 +76,19 @@ export class ConstantPool {
     return fixup;
   }
 
-  getDefinition(type: any, kind: DefinitionKind, ctx: OutputContext): o.Expression {
-    const declarations = kind == DefinitionKind.Component ?
-        this.componentDefinitions :
-        kind == DefinitionKind.Directive ? this.directiveDefinitions : this.injectorDefinitions;
-    let fixup = declarations.get(type);
+  getDefinition(type: any, kind: DefinitionKind, ctx: OutputContext, forceShared: boolean = false):
+      o.Expression {
+    const definitions = this.definitionsOf(kind);
+    let fixup = definitions.get(type);
+    let newValue = false;
     if (!fixup) {
-      const property = kind == DefinitionKind.Component ?
-          'ngComponentDef' :
-          kind == DefinitionKind.Directive ? 'ngDirectiveDef' : 'ngInjectorDef';
+      const property = this.propertyNameOf(kind);
       fixup = new FixupExpression(ctx.importExpr(type).prop(property));
-      declarations.set(type, fixup);
-    } else if (!fixup.shared) {
+      definitions.set(type, fixup);
+      newValue = true;
+    }
+
+    if ((!newValue && !fixup.shared) || (newValue && forceShared)) {
       const name = this.freshName();
       this.statements.push(
           o.variable(name).set(fixup.resolved).toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]));
@@ -104,6 +106,36 @@ export class ConstantPool {
    */
   uniqueName(prefix: string): string { return `${prefix}${this.nextNameIndex++}`; }
 
+  private definitionsOf(kind: DefinitionKind): Map<any, FixupExpression> {
+    switch (kind) {
+      case DefinitionKind.Component:
+        return this.componentDefinitions;
+      case DefinitionKind.Directive:
+        return this.directiveDefinitions;
+      case DefinitionKind.Injector:
+        return this.injectorDefinitions;
+      case DefinitionKind.Pipe:
+        return this.pipeDefinitions;
+    }
+    error(`Unknown definition kind ${kind}`);
+    return this.componentDefinitions;
+  }
+
+  public propertyNameOf(kind: DefinitionKind): string {
+    switch (kind) {
+      case DefinitionKind.Component:
+        return 'ngComponentDef';
+      case DefinitionKind.Directive:
+        return 'ngDirectiveDef';
+      case DefinitionKind.Injector:
+        return 'ngInjectorDef';
+      case DefinitionKind.Pipe:
+        return 'ngPipeDef';
+    }
+    error(`Unknown definition kind ${kind}`);
+    return '<unknown>';
+  }
+
   private freshName(): string { return this.uniqueName(CONSTANT_PREFIX); }
 
   private keyOf(expression: o.Expression) {