Fix value confusion in recursive template literals

src/compiler.ts

@@ -8136,7 +8136,8 @@ export class Compiler extends DiagnosticEmitter {
     var parts = expression.parts;
     var numParts = parts.length;
     var expressions = expression.expressions;
-    assert(numParts - 1 == expressions.length);
+    var numExpressions = expressions.length;
+    assert(numExpressions == numParts - 1);
 
     var module = this.module;
     var stringInstance = this.program.stringInstance;
@@ -8202,8 +8203,8 @@ export class Compiler extends DiagnosticEmitter {
         return this.makeCallDirect(concatMethod, [ lhs, rhs ], expression);
       }
 
-      // Compile to a `StaticArray<string>#join("") for general case
-      let length = 2 * numParts - 1;
+      // Compile to a `StaticArray<string>#join("") in the general case
+      let length = numParts + numExpressions;
       let values = new Array<usize>(length);
       values[0] = this.ensureStaticString(parts[0]);
       for (let i = 1; i < numParts; ++i) {
@@ -8215,19 +8216,33 @@ export class Compiler extends DiagnosticEmitter {
       let offset = i64_add(segment.offset, i64_new(this.program.totalOverhead));
       let joinInstance = assert(arrayInstance.getMethod("join"));
       let indexedSetInstance = assert(arrayInstance.lookupOverload(OperatorKind.INDEXED_SET, true));
-      let stmts = new Array<ExpressionRef>(numParts);
-      for (let i = 0, k = numParts - 1; i < k; ++i) {
+      let stmts = new Array<ExpressionRef>(2 * numExpressions + 1);
+      // Use one local per toString'ed subexpression, since otherwise recursion on the same
+      // static array would overwrite already prepared parts. Avoids a temporary array.
+      let temps = new Array<Local>(numExpressions);
+      let flow = this.currentFlow;
+      for (let i = 0; i < numExpressions; ++i) {
         let expression = expressions[i];
-        stmts[i] = this.makeCallDirect(indexedSetInstance, [
-          module.usize(offset),
-          module.i32(2 * i + 1),
+        let temp = flow.getTempLocal(stringType);
+        temps[i] = temp;
+        stmts[i] = module.local_set(temp.index,
           this.makeToString(
             this.compileExpression(expression, stringType),
             this.currentType, expression
-          )
+          ),
+          true
+        );
+      }
+      // Populate the static array with the toString'ed subexpressions and call .join("")
+      for (let i = 0; i < numExpressions; ++i) {
+        stmts[numExpressions + i] = this.makeCallDirect(indexedSetInstance, [
+          module.usize(offset),
+          module.i32(2 * i + 1),
+          module.local_get(temps[i].index, stringType.toRef())
         ], expression);
+        flow.freeTempLocal(temps[i]);
       }
-      stmts[numParts - 1] = this.makeCallDirect(joinInstance, [
+      stmts[2 * numExpressions] = this.makeCallDirect(joinInstance, [
         module.usize(offset),
         this.ensureStaticString("")
       ], expression);
@@ -8385,19 +8400,7 @@ export class Compiler extends DiagnosticEmitter {
 
       // otherwise allocate a new array header and make it wrap a copy of the static buffer
       } else {
-        // __newArray(length, alignLog2, classId, staticBuffer)
-        let expr = this.makeCallDirect(program.newArrayInstance, [
-          module.i32(length),
-          program.options.isWasm64
-            ? module.i64(elementType.alignLog2)
-            : module.i32(elementType.alignLog2),
-          module.i32(arrayInstance.id),
-          program.options.isWasm64
-            ? module.i64(i64_low(bufferAddress), i64_high(bufferAddress))
-            : module.i32(i64_low(bufferAddress))
-        ], expression);
-        this.currentType = arrayType;
-        return expr;
+        return this.makeNewArray(arrayInstance, length, bufferAddress, expression);
       }
     }
 
@@ -8419,16 +8422,7 @@ export class Compiler extends DiagnosticEmitter {
     // tempThis = __newArray(length, alignLog2, classId, source = 0)
     stmts.push(
       module.local_set(tempThis.index,
-        this.makeCallDirect(program.newArrayInstance, [
-          module.i32(length),
-          program.options.isWasm64
-            ? module.i64(elementType.alignLog2)
-            : module.i32(elementType.alignLog2),
-          module.i32(arrayInstance.id),
-          program.options.isWasm64
-            ? module.i64(0)
-            : module.i32(0)
-        ], expression),
+        this.makeNewArray(arrayInstance, length, i64_new(0), expression),
         arrayType.isManaged
       )
     );
@@ -8466,6 +8460,37 @@ export class Compiler extends DiagnosticEmitter {
     return module.flatten(stmts, arrayTypeRef);
   }
 
+  /** Makes a new array instance from a static buffer segment. */
+  private makeNewArray(
+    /** Concrete array class. */
+    arrayInstance: Class,
+    /** Length of the array. */
+    length: i32,
+    /** Source address to copy from. Array is zeroed if `0`. */
+    source: i64,
+    /** Report node. */
+    reportNode: Node
+  ): ExpressionRef {
+    var program = this.program;
+    var module = this.module;
+    assert(!arrayInstance.extends(program.staticArrayPrototype));
+    var elementType = arrayInstance.getArrayValueType(); // asserts
+
+    // __newArray(length, alignLog2, classId, staticBuffer)
+    var expr = this.makeCallDirect(program.newArrayInstance, [
+      module.i32(length),
+      program.options.isWasm64
+        ? module.i64(elementType.alignLog2)
+        : module.i32(elementType.alignLog2),
+      module.i32(arrayInstance.id),
+      program.options.isWasm64
+        ? module.i64(i64_low(source), i64_high(source))
+        : module.i32(i64_low(source))
+    ], reportNode);
+    this.currentType = arrayInstance.type;
+    return expr;
+  }
+
   /** Compiles a special `fixed` array literal. */
   private compileStaticArrayLiteral(
     expression: ArrayLiteralExpression,