refactor(compiler): add spread elements to the output AST

Adds spread elements to the output AST which can be used in arrays and function calls.

Author: crisbeto

packages/compiler-cli/src/ngtsc/translator/src/translator.ts

@@ -415,6 +415,11 @@ export class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     throw new Error('Method not implemented');
   }
 
+  visitSpreadElementExpr(ast: o.outputAst.SpreadElementExpr, context: any): TExpression {
+    const expression = ast.expression.visitExpression(this, context);
+    return this.setSourceMapRange(this.factory.createSpreadElement(expression), ast.sourceSpan);
+  }
+
   visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, _context: Context): any {
     this.recordWrappedNode(ast);
     return ast.node;

packages/compiler-cli/src/ngtsc/translator/src/type_translator.ts

@@ -280,6 +280,11 @@ class TypeTranslatorVisitor implements o.ExpressionVisitor, o.TypeVisitor {
     throw new Error('Method not implemented.');
   }
 
+  visitSpreadElementExpr(ast: o.outputAst.SpreadElementExpr, context: any) {
+    const typeNode = this.translateExpression(ast.expression, context);
+    return ts.factory.createRestTypeNode(typeNode);
+  }
+
   private translateType(type: o.Type, context: Context): ts.TypeNode {
     const typeNode = type.visitType(this, context);
     if (!ts.isTypeNode(typeNode)) {

packages/compiler/src/compiler.ts

@@ -118,6 +118,7 @@ export {
   WrappedNodeExpr,
   LiteralMapPropertyAssignment,
   LiteralMapSpreadAssignment,
+  SpreadElementExpr,
 } from './output/output_ast';
 export {JitEvaluator} from './output/output_jit';
 export {SourceMap} from './output/source_map';

packages/compiler/src/output/abstract_emitter.ts

@@ -486,6 +486,10 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
     // TODO: Do we *need* to parenthesize everything?
     ast.expr.visitExpression(this, ctx);
   }
+  visitSpreadElementExpr(ast: o.SpreadElementExpr, ctx: EmitterVisitorContext) {
+    ctx.print(ast, '...');
+    ast.expression.visitExpression(this, ctx);
+  }
   visitAllExpressions(
     expressions: o.Expression[],
     ctx: EmitterVisitorContext,

packages/compiler/src/output/output_ast.ts

@@ -1425,6 +1425,31 @@ export class CommaExpr extends Expression {
   }
 }
 
+export class SpreadElementExpr extends Expression {
+  constructor(
+    public expression: Expression,
+    sourceSpan?: ParseSourceSpan | null,
+  ) {
+    super(null, sourceSpan);
+  }
+
+  override isEquivalent(e: Expression): boolean {
+    return e instanceof SpreadElementExpr && this.expression.isEquivalent(e.expression);
+  }
+
+  override isConstant() {
+    return this.expression.isConstant();
+  }
+
+  override visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitSpreadElementExpr(this, context);
+  }
+
+  override clone(): SpreadElementExpr {
+    return new SpreadElementExpr(this.expression.clone(), this.sourceSpan);
+  }
+}
+
 export interface ExpressionVisitor {
   visitReadVarExpr(ast: ReadVarExpr, context: any): any;
   visitInvokeFunctionExpr(ast: InvokeFunctionExpr, context: any): any;
@@ -1452,6 +1477,7 @@ export interface ExpressionVisitor {
   visitArrowFunctionExpr(ast: ArrowFunctionExpr, context: any): any;
   visitParenthesizedExpr(ast: ParenthesizedExpr, context: any): any;
   visitRegularExpressionLiteral(ast: RegularExpressionLiteralExpr, context: any): any;
+  visitSpreadElementExpr(ast: SpreadElementExpr, context: any): any;
 }
 
 export const NULL_EXPR = new LiteralExpr(null, null, null);
@@ -1772,6 +1798,10 @@ export class RecursiveAstVisitor implements StatementVisitor, ExpressionVisitor
     ast.expr.visitExpression(this, context);
     return this.visitExpression(ast, context);
   }
+  visitSpreadElementExpr(ast: SpreadElementExpr, context: any): any {
+    ast.expression.visitExpression(this, context);
+    return this.visitExpression(ast, context);
+  }
   visitAllExpressions(exprs: Expression[], context: any): void {
     exprs.forEach((expr) => expr.visitExpression(this, context));
   }