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

PR Close #22034

packages/compiler/src/expression_parser/ast.ts

@@ -435,6 +435,173 @@ export class AstTransformer implements AstVisitor {
   }
 }
 
+// A transformer that only creates new nodes if the transformer makes a change or
+// a change is made a child node.
+export class AstMemoryEfficientTransformer implements AstVisitor {
+  visitImplicitReceiver(ast: ImplicitReceiver, context: any): AST { return ast; }
+
+  visitInterpolation(ast: Interpolation, context: any): Interpolation {
+    const expressions = this.visitAll(ast.expressions);
+    if (expressions !== ast.expressions)
+      return new Interpolation(ast.span, ast.strings, expressions);
+    return ast;
+  }
+
+  visitLiteralPrimitive(ast: LiteralPrimitive, context: any): AST { return ast; }
+
+  visitPropertyRead(ast: PropertyRead, context: any): AST {
+    const receiver = ast.receiver.visit(this);
+    if (receiver !== ast.receiver) {
+      return new PropertyRead(ast.span, receiver, ast.name);
+    }
+    return ast;
+  }
+
+  visitPropertyWrite(ast: PropertyWrite, context: any): AST {
+    const receiver = ast.receiver.visit(this);
+    const value = ast.value.visit(this);
+    if (receiver !== ast.receiver || value !== ast.value) {
+      return new PropertyWrite(ast.span, receiver, ast.name, value);
+    }
+    return ast;
+  }
+
+  visitSafePropertyRead(ast: SafePropertyRead, context: any): AST {
+    const receiver = ast.receiver.visit(this);
+    if (receiver !== ast.receiver) {
+      return new SafePropertyRead(ast.span, receiver, ast.name);
+    }
+    return ast;
+  }
+
+  visitMethodCall(ast: MethodCall, context: any): AST {
+    const receiver = ast.receiver.visit(this);
+    if (receiver !== ast.receiver) {
+      return new MethodCall(ast.span, receiver, ast.name, this.visitAll(ast.args));
+    }
+    return ast;
+  }
+
+  visitSafeMethodCall(ast: SafeMethodCall, context: any): AST {
+    const receiver = ast.receiver.visit(this);
+    const args = this.visitAll(ast.args);
+    if (receiver !== ast.receiver || args !== ast.args) {
+      return new SafeMethodCall(ast.span, receiver, ast.name, args);
+    }
+    return ast;
+  }
+
+  visitFunctionCall(ast: FunctionCall, context: any): AST {
+    const target = ast.target && ast.target.visit(this);
+    const args = this.visitAll(ast.args);
+    if (target !== ast.target || args !== ast.args) {
+      return new FunctionCall(ast.span, target, args);
+    }
+    return ast;
+  }
+
+  visitLiteralArray(ast: LiteralArray, context: any): AST {
+    const expressions = this.visitAll(ast.expressions);
+    if (expressions !== ast.expressions) {
+      return new LiteralArray(ast.span, expressions);
+    }
+    return ast;
+  }
+
+  visitLiteralMap(ast: LiteralMap, context: any): AST {
+    const values = this.visitAll(ast.values);
+    if (values !== ast.values) {
+      return new LiteralMap(ast.span, ast.keys, values);
+    }
+    return ast;
+  }
+
+  visitBinary(ast: Binary, context: any): AST {
+    const left = ast.left.visit(this);
+    const right = ast.right.visit(this);
+    if (left !== ast.left || right !== ast.right) {
+      return new Binary(ast.span, ast.operation, left, right);
+    }
+    return ast;
+  }
+
+  visitPrefixNot(ast: PrefixNot, context: any): AST {
+    const expression = ast.expression.visit(this);
+    if (expression !== ast.expression) {
+      return new PrefixNot(ast.span, expression);
+    }
+    return ast;
+  }
+
+  visitNonNullAssert(ast: NonNullAssert, context: any): AST {
+    const expression = ast.expression.visit(this);
+    if (expression !== ast.expression) {
+      return new NonNullAssert(ast.span, expression);
+    }
+    return ast;
+  }
+
+  visitConditional(ast: Conditional, context: any): AST {
+    const condition = ast.condition.visit(this);
+    const trueExp = ast.trueExp.visit(this);
+    const falseExp = ast.falseExp.visit(this);
+    if (condition !== ast.condition || trueExp !== ast.trueExp || falseExp !== falseExp) {
+      return new Conditional(ast.span, condition, trueExp, falseExp);
+    }
+    return ast;
+  }
+
+  visitPipe(ast: BindingPipe, context: any): AST {
+    const exp = ast.exp.visit(this);
+    const args = this.visitAll(ast.args);
+    if (exp !== ast.exp || args !== ast.args) {
+      return new BindingPipe(ast.span, exp, ast.name, args);
+    }
+    return ast;
+  }
+
+  visitKeyedRead(ast: KeyedRead, context: any): AST {
+    const obj = ast.obj.visit(this);
+    const key = ast.key.visit(this);
+    if (obj !== ast.obj || key !== ast.key) {
+      return new KeyedRead(ast.span, obj, key);
+    }
+    return ast;
+  }
+
+  visitKeyedWrite(ast: KeyedWrite, context: any): AST {
+    const obj = ast.obj.visit(this);
+    const key = ast.key.visit(this);
+    const value = ast.value.visit(this);
+    if (obj !== ast.obj || key !== ast.key || value !== ast.value) {
+      return new KeyedWrite(ast.span, obj, key, value);
+    }
+    return ast;
+  }
+
+  visitAll(asts: any[]): any[] {
+    const res = new Array(asts.length);
+    let modified = false;
+    for (let i = 0; i < asts.length; ++i) {
+      const original = asts[i];
+      const value = original.visit(this);
+      res[i] = value;
+      modified = modified || value !== original;
+    }
+    return modified ? res : asts;
+  }
+
+  visitChain(ast: Chain, context: any): AST {
+    const expressions = this.visitAll(ast.expressions);
+    if (expressions !== ast.expressions) {
+      return new Chain(ast.span, expressions);
+    }
+    return ast;
+  }
+
+  visitQuote(ast: Quote, context: any): AST { return ast; }
+}
+
 export function visitAstChildren(ast: AST, visitor: AstVisitor, context?: any) {
   function visit(ast: AST) {
     visitor.visit && visitor.visit(ast, context) || ast.visit(visitor, context);