refactor(compiler): support spread elements in output AST

Updates the output AST to account for spread elements.

Author: crisbeto

packages/compiler/src/constant_pool.ts

@@ -175,39 +175,6 @@ export class ConstantPool {
     return this.sharedConstants.get(key)!;
   }
 
-  getLiteralFactory(literal: o.LiteralArrayExpr | o.LiteralMapExpr): {
-    literalFactory: o.Expression;
-    literalFactoryArguments: o.Expression[];
-  } {
-    // Create a pure function that builds an array of a mix of constant and variable expressions
-    if (literal instanceof o.LiteralArrayExpr) {
-      const argumentsForKey = literal.entries.map((e) => (e.isConstant() ? e : UNKNOWN_VALUE_KEY));
-      const key = GenericKeyFn.INSTANCE.keyOf(o.literalArr(argumentsForKey));
-      return this._getLiteralFactory(key, literal.entries, (entries) => o.literalArr(entries));
-    } else {
-      const expressionForKey = o.literalMap(
-        literal.entries.map((e) => ({
-          key: e.key,
-          value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,
-          quoted: e.quoted,
-        })),
-      );
-      const key = GenericKeyFn.INSTANCE.keyOf(expressionForKey);
-      return this._getLiteralFactory(
-        key,
-        literal.entries.map((e) => e.value),
-        (entries) =>
-          o.literalMap(
-            entries.map((value, index) => ({
-              key: literal.entries[index].key,
-              value,
-              quoted: literal.entries[index].quoted,
-            })),
-          ),
-      );
-    }
-  }
-
   // TODO: useUniqueName(false) is necessary for naming compatibility with
   // TemplateDefinitionBuilder, but should be removed once Template Pipeline is the default.
   getSharedFunctionReference(
@@ -246,35 +213,6 @@ export class ConstantPool {
     return o.variable(name);
   }
 
-  private _getLiteralFactory(
-    key: string,
-    values: o.Expression[],
-    resultMap: (parameters: o.Expression[]) => o.Expression,
-  ): {literalFactory: o.Expression; literalFactoryArguments: o.Expression[]} {
-    let literalFactory = this.literalFactories.get(key);
-    const literalFactoryArguments = values.filter((e) => !e.isConstant());
-    if (!literalFactory) {
-      const resultExpressions = values.map((e, index) =>
-        e.isConstant() ? this.getConstLiteral(e, true) : o.variable(`a${index}`),
-      );
-      const parameters = resultExpressions
-        .filter(isVariable)
-        .map((e) => new o.FnParam(e.name!, o.DYNAMIC_TYPE));
-      const pureFunctionDeclaration = o.arrowFn(
-        parameters,
-        resultMap(resultExpressions),
-        o.INFERRED_TYPE,
-      );
-      const name = this.freshName();
-      this.statements.push(
-        new o.DeclareVarStmt(name, pureFunctionDeclaration, o.INFERRED_TYPE, o.StmtModifier.Final),
-      );
-      literalFactory = o.variable(name);
-      this.literalFactories.set(key, literalFactory);
-    }
-    return {literalFactory, literalFactoryArguments};
-  }
-
   /**
    * Produce a unique name in the context of this pool.
    *
@@ -322,11 +260,15 @@ export class GenericKeyFn implements ExpressionKeyFn {
     } else if (expr instanceof o.LiteralMapExpr) {
       const entries: string[] = [];
       for (const entry of expr.entries) {
-        let key = entry.key;
-        if (entry.quoted) {
-          key = `"${key}"`;
+        if (entry instanceof o.LiteralMapSpreadAssignment) {
+          entries.push('...' + this.keyOf(entry.expression));
+        } else {
+          let key = entry.key;
+          if (entry.quoted) {
+            key = `"${key}"`;
+          }
+          entries.push(key + ':' + this.keyOf(entry.value));
         }
-        entries.push(key + ':' + this.keyOf(entry.value));
       }
       return `{${entries.join(',')}}`;
     } else if (expr instanceof o.ExternalExpr) {

packages/compiler/src/output/abstract_emitter.ts

@@ -456,11 +456,16 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
     ctx.print(ast, `{`);
     this.visitAllObjects(
       (entry) => {
-        ctx.print(
-          ast,
-          `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`,
-        );
-        entry.value.visitExpression(this, ctx);
+        if (entry instanceof o.LiteralMapSpreadAssignment) {
+          ctx.print(ast, '...');
+          entry.expression.visitExpression(this, ctx);
+        } else {
+          ctx.print(
+            ast,
+            `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`,
+          );
+          entry.value.visitExpression(this, ctx);
+        }
       },
       ast.entries,
       ctx,

packages/compiler/src/output/output_ast.ts

@@ -1331,21 +1331,44 @@ export class LiteralArrayExpr extends Expression {
   }
 }
 
-export class LiteralMapEntry {
+export class LiteralMapPropertyAssignment {
   constructor(
     public key: string,
     public value: Expression,
     public quoted: boolean,
   ) {}
-  isEquivalent(e: LiteralMapEntry): boolean {
+
+  isEquivalent(e: LiteralMapPropertyAssignment): boolean {
     return this.key === e.key && this.value.isEquivalent(e.value);
   }
 
-  clone(): LiteralMapEntry {
-    return new LiteralMapEntry(this.key, this.value.clone(), this.quoted);
+  clone(): LiteralMapPropertyAssignment {
+    return new LiteralMapPropertyAssignment(this.key, this.value.clone(), this.quoted);
+  }
+
+  isConstant() {
+    return this.value.isConstant();
   }
 }
 
+export class LiteralMapSpreadAssignment {
+  constructor(public expression: Expression) {}
+
+  isEquivalent(e: LiteralMapSpreadAssignment): boolean {
+    return e instanceof LiteralMapSpreadAssignment && this.expression.isEquivalent(e.expression);
+  }
+
+  clone(): LiteralMapSpreadAssignment {
+    return new LiteralMapSpreadAssignment(this.expression.clone());
+  }
+
+  isConstant() {
+    return this.expression.isConstant();
+  }
+}
+
+export type LiteralMapEntry = LiteralMapPropertyAssignment | LiteralMapSpreadAssignment;
+
 export class LiteralMapExpr extends Expression {
   public valueType: Type | null = null;
   constructor(
@@ -1364,7 +1387,7 @@ export class LiteralMapExpr extends Expression {
   }
 
   override isConstant() {
-    return this.entries.every((e) => e.value.isConstant());
+    return this.entries.every((e) => e.isConstant());
   }
 
   override visitExpression(visitor: ExpressionVisitor, context: any): any {
@@ -1724,7 +1747,13 @@ export class RecursiveAstVisitor implements StatementVisitor, ExpressionVisitor
     return this.visitExpression(ast, context);
   }
   visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
-    ast.entries.forEach((entry) => entry.value.visitExpression(this, context));
+    ast.entries.forEach((entry) => {
+      if (entry instanceof LiteralMapSpreadAssignment) {
+        entry.expression.visitExpression(this, context);
+      } else {
+        entry.value.visitExpression(this, context);
+      }
+    });
     return this.visitExpression(ast, context);
   }
   visitCommaExpr(ast: CommaExpr, context: any): any {
@@ -1847,7 +1876,7 @@ export function literalMap(
   type: MapType | null = null,
 ): LiteralMapExpr {
   return new LiteralMapExpr(
-    values.map((e) => new LiteralMapEntry(e.key, e.value, e.quoted)),
+    values.map((e) => new LiteralMapPropertyAssignment(e.key, e.value, e.quoted)),
     type,
     null,
   );

packages/compiler/src/output/output_jit.ts

@@ -115,7 +115,8 @@ export class JitEmitterVisitor extends AbstractJsEmitterVisitor {
     const stmt = new o.ReturnStatement(
       new o.LiteralMapExpr(
         this._evalExportedVars.map(
-          (resultVar) => new o.LiteralMapEntry(resultVar, o.variable(resultVar), false),
+          (resultVar) =>
+            new o.LiteralMapPropertyAssignment(resultVar, o.variable(resultVar), false),
         ),
       ),
     );

packages/compiler/src/template/pipeline/ir/src/expression.ts

@@ -1275,12 +1275,12 @@ export function transformExpressionsInExpression(
       expr.entries[i] = transformExpressionsInExpression(expr.entries[i], transform, flags);
     }
   } else if (expr instanceof o.LiteralMapExpr) {
-    for (let i = 0; i < expr.entries.length; i++) {
-      expr.entries[i].value = transformExpressionsInExpression(
-        expr.entries[i].value,
-        transform,
-        flags,
-      );
+    for (const entry of expr.entries) {
+      if (entry instanceof o.LiteralMapSpreadAssignment) {
+        entry.expression = transformExpressionsInExpression(entry.expression, transform, flags);
+      } else {
+        entry.value = transformExpressionsInExpression(entry.value, transform, flags);
+      }
     }
   } else if (expr instanceof o.ConditionalExpr) {
     expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);

packages/compiler/src/template/pipeline/src/phases/pure_literal_structures.ts

@@ -53,15 +53,32 @@ function transformLiteralMap(expr: o.LiteralMapExpr): o.Expression {
   let derivedEntries: o.LiteralMapEntry[] = [];
   const nonConstantArgs: o.Expression[] = [];
   for (const entry of expr.entries) {
+    if (entry instanceof o.LiteralMapSpreadAssignment) {
+      if (entry.expression.isConstant()) {
+        derivedEntries.push(entry);
+      } else {
+        const idx = nonConstantArgs.length;
+        nonConstantArgs.push(entry.expression);
+        derivedEntries.push(
+          new o.LiteralMapSpreadAssignment(new ir.PureFunctionParameterExpr(idx)),
+        );
+      }
+      continue;
+    }
+
     if (entry.value.isConstant()) {
       derivedEntries.push(entry);
     } else {
       const idx = nonConstantArgs.length;
       nonConstantArgs.push(entry.value);
       derivedEntries.push(
-        new o.LiteralMapEntry(entry.key, new ir.PureFunctionParameterExpr(idx), entry.quoted),
+        new o.LiteralMapPropertyAssignment(
+          entry.key,
+          new ir.PureFunctionParameterExpr(idx),
+          entry.quoted,
+        ),
       );
     }
   }
-  return new ir.PureFunctionExpr(o.literalMap(derivedEntries), nonConstantArgs);
+  return new ir.PureFunctionExpr(new o.LiteralMapExpr(derivedEntries), nonConstantArgs);
 }

packages/core/schematics/migrations/signal-migration/src/passes/reference_resolution/template_reference_visitor.ts

@@ -272,7 +272,8 @@ export class TemplateExpressionReferenceVisitor<
   // E.g. `{bla}` may be transformed to `{bla: bla()}`.
   override visitLiteralMap(ast: LiteralMap, context: any) {
     for (const [idx, key] of ast.keys.entries()) {
-      this.isInsideObjectShorthandExpression = !!key.isShorthandInitialized;
+      this.isInsideObjectShorthandExpression =
+        key.kind === 'property' && !!key.isShorthandInitialized;
       (ast.values[idx] as AST).visit(this, context);
       this.isInsideObjectShorthandExpression = false;
     }