refactor(compiler): Add support for spreaded expressions

Expression that return iterables can now be spreaded if needed.

Author: JeanMeche

packages/compiler-cli/linker/babel/src/ast/babel_ast_factory.ts

@@ -160,6 +160,10 @@ export class BabelAstFactory implements AstFactory<t.Statement, t.Expression> {
 
   createReturnStatement = t.returnStatement;
 
+  createSpreadedExpression(expression: t.Expression): t.Expression {
+    return t.spreadElement(expression) as any;
+  }
+
   createTaggedTemplate(tag: t.Expression, template: TemplateLiteral<t.Expression>): t.Expression {
     const elements = template.elements.map((element, i) =>
       this.setSourceMapRange(

packages/compiler-cli/linker/babel/test/ast/babel_ast_factory_spec.ts

@@ -300,6 +300,14 @@ describe('BabelAstFactory', () => {
     });
   });
 
+  describe('createSpreadedExpression()', () => {
+    it('should create a spreaded expression of an array', () => {
+      const expr = expression.ast`[3,4,5]`;
+      const returnStmt = factory.createSpreadedExpression(expr);
+      expect(generate(returnStmt).code).toEqual('...[3, 4, 5]');
+    });
+  });
+
   describe('createTaggedTemplate()', () => {
     it('should create a tagged template node from the tag, elements and expressions', () => {
       const elements = [

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

@@ -204,6 +204,13 @@ export interface AstFactory<TStatement, TExpression> {
    */
   createReturnStatement(expression: TExpression | null): TStatement;
 
+  /**
+   * Create a spreaded express (e.g. `...myIterable`)
+   *
+   * @param expression the expression to spread
+   */
+  createSpreadedExpression(expression: TExpression): TExpression;
+
   /**
    * Create a tagged template literal string. E.g.
    *

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

@@ -402,6 +402,10 @@ export class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     );
   }
 
+  visitSpreadedIterableExpr(ast: o.outputAst.SpreadedIterableExpr, context: any) {
+    return this.factory.createSpreadedExpression(ast.iterable.visitExpression(this, context));
+  }
+
   visitLiteralArrayExpr(ast: o.LiteralArrayExpr, context: Context): TExpression {
     return this.factory.createArrayLiteral(
       ast.entries.map((expr) =>

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

@@ -221,6 +221,10 @@ class TypeTranslatorVisitor implements o.ExpressionVisitor, o.TypeVisitor {
     throw new Error('Method not implemented.');
   }
 
+  visitSpreadedIterableExpr(ast: o.outputAst.SpreadedIterableExpr, context: any) {
+    throw new Error('Method not implemented.');
+  }
+
   visitLiteralArrayExpr(ast: o.LiteralArrayExpr, context: Context): ts.TupleTypeNode {
     const values = ast.entries.map((expr) => this.translateExpression(expr, context));
     return ts.factory.createTupleTypeNode(values);

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

@@ -239,6 +239,10 @@ export class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Express
     return ts.factory.createReturnStatement(expression ?? undefined);
   }
 
+  createSpreadedExpression(expression: ts.Expression): ts.Expression {
+    return ts.factory.createSpreadElement(expression);
+  }
+
   createTaggedTemplate(
     tag: ts.Expression,
     template: TemplateLiteral<ts.Expression>,

packages/compiler/src/output/abstract_emitter.ts

@@ -484,6 +484,11 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
     ctx.print(ast, `]`);
     return null;
   }
+  visitSpreadedIterableExpr(ast: o.SpreadedIterableExpr, ctx: EmitterVisitorContext): any {
+    ctx.print(ast, `...`);
+    ast.iterable.visitExpression(this, ctx);
+    return null;
+  }
   visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: EmitterVisitorContext): any {
     ctx.print(ast, `{`);
     this.visitAllObjects(

packages/compiler/src/output/output_ast.ts

@@ -1303,6 +1303,28 @@ export class LiteralArrayExpr extends Expression {
   }
 }
 
+export class SpreadedIterableExpr extends Expression {
+  public iterable: Expression;
+  constructor(iterable: Expression, type?: Type | null, sourceSpan?: ParseSourceSpan | null) {
+    super(type, sourceSpan);
+    this.iterable = iterable;
+  }
+
+  override isEquivalent(e: Expression): boolean {
+    return this.iterable.isEquivalent(e);
+  }
+  override isConstant(): boolean {
+    return false;
+  }
+  override visitExpression(visitor: ExpressionVisitor, context: any): any {
+    return visitor.visitSpreadedIterableExpr(this, context);
+  }
+
+  override clone(): SpreadedIterableExpr {
+    return new SpreadedIterableExpr(this.iterable.clone(), this.type, this.sourceSpan);
+  }
+}
+
 export class LiteralMapEntry {
   constructor(
     public key: string,
@@ -1394,6 +1416,7 @@ export interface ExpressionVisitor {
   visitReadPropExpr(ast: ReadPropExpr, context: any): any;
   visitReadKeyExpr(ast: ReadKeyExpr, context: any): any;
   visitLiteralArrayExpr(ast: LiteralArrayExpr, context: any): any;
+  visitSpreadedIterableExpr(ast: SpreadedIterableExpr, context: any): any;
   visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
   visitCommaExpr(ast: CommaExpr, context: any): any;
   visitWrappedNodeExpr(ast: WrappedNodeExpr<any>, context: any): any;
@@ -1698,6 +1721,10 @@ export class RecursiveAstVisitor implements StatementVisitor, ExpressionVisitor
     this.visitAllExpressions(ast.entries, context);
     return this.visitExpression(ast, context);
   }
+  visitSpreadedIterableExpr(ast: SpreadedIterableExpr, context: any): any {
+    this.visitExpression(ast.iterable, context);
+    return this.visitExpression(ast, context);
+  }
   visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
     ast.entries.forEach((entry) => entry.value.visitExpression(this, context));
     return this.visitExpression(ast, context);
@@ -1816,6 +1843,14 @@ export function literalMap(
   );
 }
 
+export function spreaded(
+  iterable: Expression,
+  type?: Type,
+  sourceSpan?: ParseSourceSpan | null,
+): SpreadedIterableExpr {
+  return new SpreadedIterableExpr(iterable, type, sourceSpan);
+}
+
 export function unary(
   operator: UnaryOperator,
   expr: Expression,