refactor(compiler): add spread elements to expression AST

Updates the expression AST to have support for spread elements inside object literals.

Author: crisbeto

packages/compiler/src/compiler.ts

@@ -116,6 +116,8 @@ export {
   UnaryOperatorExpr,
   VoidExpr,
   WrappedNodeExpr,
+  LiteralMapPropertyAssignment,
+  LiteralMapSpreadAssignment,
 } from './output/output_ast';
 export {JitEvaluator} from './output/output_jit';
 export {SourceMap} from './output/source_map';

packages/compiler/src/expression_parser/ast.ts

@@ -210,14 +210,23 @@ export class LiteralArray extends AST {
   }
 }
 
-export interface LiteralMapKey {
+export interface LiteralMapPropertyKey {
+  kind: 'property';
   key: string;
   quoted: boolean;
   span: ParseSpan;
   sourceSpan: AbsoluteSourceSpan;
   isShorthandInitialized?: boolean;
 }
 
+export interface LiteralMapSpreadKey {
+  kind: 'spread';
+  span: ParseSpan;
+  sourceSpan: AbsoluteSourceSpan;
+}
+
+export type LiteralMapKey = LiteralMapPropertyKey | LiteralMapSpreadKey;
+
 export class LiteralMap extends AST {
   constructor(
     span: ParseSpan,

packages/compiler/src/expression_parser/parser.ts

@@ -1200,6 +1200,7 @@ class _ParseAST {
         const keySpan = this.span(keyStart);
         const keySourceSpan = this.sourceSpan(keyStart);
         const literalMapKey: LiteralMapKey = {
+          kind: 'property',
           key,
           quoted,
           span: keySpan,

packages/compiler/src/expression_parser/serializer.ts

@@ -58,7 +58,12 @@ class SerializeExpressionVisitor implements expr.AstVisitor {
 
   visitLiteralMap(ast: expr.LiteralMap, context: any): string {
     return `{${zip(
-      ast.keys.map((literal) => (literal.quoted ? `'${literal.key}'` : literal.key)),
+      ast.keys.map((literal) => {
+        if (literal.kind === 'spread') {
+          return '...';
+        }
+        return literal.quoted ? `'${literal.key}'` : literal.key;
+      }),
       ast.values.map((value) => value.visit(this, context)),
     )
       .map(([key, value]) => `${key}: ${value}`)

packages/compiler/src/render3/r3_deferred_triggers.ts

@@ -616,13 +616,17 @@ function createViewportTrigger(
 
     if (!(parsed.ast instanceof LiteralMap)) {
       throw new Error('Options parameter of the "viewport" trigger must be an object literal');
-    } else if (parsed.ast.keys.some((key) => key.key === 'root')) {
+    } else if (parsed.ast.keys.some((key) => key.kind === 'spread')) {
+      throw new Error('Spread operator are not allowed in this context');
+    } else if (parsed.ast.keys.some((key) => key.kind === 'property' && key.key === 'root')) {
       throw new Error(
         'The "root" option is not supported in the options parameter of the "viewport" trigger',
       );
     }
 
-    const triggerIndex = parsed.ast.keys.findIndex((key) => key.key === 'trigger');
+    const triggerIndex = parsed.ast.keys.findIndex(
+      (key) => key.kind === 'property' && key.key === 'trigger',
+    );
 
     if (triggerIndex === -1) {
       reference = null;

packages/compiler/src/template/pipeline/src/ingest.ts

@@ -1140,10 +1140,13 @@ function convertAst(
     throw new Error(`AssertionError: Chain in unknown context`);
   } else if (ast instanceof e.LiteralMap) {
     const entries = ast.keys.map((key, idx) => {
-      const value = ast.values[idx];
+      const value = convertAst(ast.values[idx], job, baseSourceSpan);
+
       // TODO: should literals have source maps, or do we just map the whole surrounding
       // expression?
-      return new o.LiteralMapEntry(key.key, convertAst(value, job, baseSourceSpan), key.quoted);
+      return key.kind === 'spread'
+        ? new o.LiteralMapSpreadAssignment(value)
+        : new o.LiteralMapPropertyAssignment(key.key, value, key.quoted);
     });
     return new o.LiteralMapExpr(entries, undefined, convertSourceSpan(ast.span, baseSourceSpan));
   } else if (ast instanceof e.LiteralArray) {

packages/compiler/test/expression_parser/parser_spec.ts

@@ -19,6 +19,7 @@ import {
   VariableBinding,
   BindingPipeType,
   ParseSpan,
+  LiteralMapPropertyKey,
 } from '../../src/expression_parser/ast';
 import {ParseError} from '../../src/parse_util';
 import {Lexer} from '../../src/expression_parser/lexer';
@@ -914,9 +915,10 @@ describe('parser', () => {
     it('should expose object shorthand information in AST', () => {
       const parser = new Parser(new Lexer());
       const ast = parser.parseBinding('{bla}', getFakeSpan(), 0);
-      expect(ast.ast instanceof LiteralMap).toBe(true);
-      expect((ast.ast as LiteralMap).keys.length).toBe(1);
-      expect((ast.ast as LiteralMap).keys[0].isShorthandInitialized).toBe(true);
+      const map = ast.ast as LiteralMap;
+      expect(map instanceof LiteralMap).toBe(true);
+      expect(map.keys.length).toBe(1);
+      expect((map.keys[0] as LiteralMapPropertyKey).isShorthandInitialized).toBe(true);
     });
   });
 

packages/compiler/test/expression_parser/utils/unparser.ts

@@ -161,8 +161,14 @@ class Unparser implements AstVisitor {
       if (!isFirst) this._expression += ', ';
       isFirst = false;
       const key = ast.keys[i];
-      this._expression += key.quoted ? JSON.stringify(key.key) : key.key;
-      this._expression += ': ';
+
+      if (key.kind === 'spread') {
+        this._expression += '...';
+      } else {
+        this._expression += key.quoted ? JSON.stringify(key.key) : key.key;
+        this._expression += ': ';
+      }
+
       this._visit(ast.values[i]);
     }