Implemented spread expression transformation (#338)

Perryvw · web-flow · commit e42c5be340a5 · 2019-01-19T14:36:29.000+01:00
* Implemented spread element transformation

* Removed focusTest that I thought was already removed

* Use createUnpackCall instead of re-implementing it
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -964,7 +964,10 @@ export class LuaTransformer {
                     )];
                 } else {
                     // local vars = this.transpileDestructingAssignmentValue(node.initializer);
-                    const initializer = this.createUnpackCall(this.transformExpression(statement.initializer));
+                    const initializer = this.createUnpackCall(
+                        this.transformExpression(statement.initializer),
+                        statement.initializer
+                    );
                     return [tstl.createVariableDeclarationStatement(vars, initializer)];
                 }
             } else {
@@ -1058,7 +1061,10 @@ export class LuaTransformer {
                         .map(elem => this.transformExpression(elem)));
                 } else if (!tsHelper.isTupleReturnCall(statement.expression, this.checker)) {
                     // If return expression is not another TupleReturn call, unpack it
-                    const expression = this.createUnpackCall(this.transformExpression(statement.expression));
+                    const expression = this.createUnpackCall(
+                        this.transformExpression(statement.expression),
+                        statement.expression
+                    );
                     return tstl.createReturnStatement([expression]);
                 }
             }
@@ -1133,15 +1139,15 @@ export class LuaTransformer {
             // Declaration of new variable
             const variableDeclarations = this.transformVariableDeclaration(initializer.declarations[0]);
             if (ts.isArrayBindingPattern(initializer.declarations[0].name)) {
-                expression = this.createUnpackCall(expression);
+                expression = this.createUnpackCall(expression, initializer);
             }
             return tstl.createVariableDeclarationStatement(variableDeclarations[0].left, expression);
 
         } else {
             // Assignment to existing variable
             let variables: tstl.IdentifierOrTableIndexExpression | tstl.IdentifierOrTableIndexExpression[];
             if (ts.isArrayLiteralExpression(initializer)) {
-                expression = this.createUnpackCall(expression);
+                expression = this.createUnpackCall(expression, initializer);
                 variables = initializer.elements
                     .map(e => this.transformExpression(e)) as tstl.IdentifierOrTableIndexExpression[];
             } else {
@@ -1483,7 +1489,7 @@ export class LuaTransformer {
             case ts.SyntaxKind.TypeOfExpression:
                 return this.transformTypeOfExpression(expression as ts.TypeOfExpression);
             case ts.SyntaxKind.SpreadElement:
-                throw new Error("Not yet implemented");
+                return this.transformSpreadElement(expression as ts.SpreadElement);
             case ts.SyntaxKind.NonNullExpression:
                 return this.transformExpression((expression as ts.NonNullExpression).expression);
             case ts.SyntaxKind.EmptyStatement:
@@ -1635,7 +1641,7 @@ export class LuaTransformer {
             } else if (tsHelper.isTupleReturnCall(expression.right, this.checker)) {
                 right = [this.transformExpression(expression.right)];
             } else {
-                right = [this.createUnpackCall(this.transformExpression(expression.right))];
+                right = [this.createUnpackCall(this.transformExpression(expression.right), expression.right)];
             }
             return tstl.createAssignmentStatement(
                 left as tstl.IdentifierOrTableIndexExpression[],
@@ -1667,7 +1673,7 @@ export class LuaTransformer {
             } else if (tsHelper.isTupleReturnCall(expression.right, this.checker)) {
                 right = [this.transformExpression(expression.right)];
             } else {
-                right = [this.createUnpackCall(this.transformExpression(expression.right))];
+                right = [this.createUnpackCall(this.transformExpression(expression.right), expression.right)];
             }
             const tmps = expression.left.elements.map((_, i) => tstl.createIdentifier(`____TS_tmp${i}`));
             const statements: tstl.Statement[] = [
@@ -2765,6 +2771,12 @@ export class LuaTransformer {
         );
     }
 
+    public transformSpreadElement(expression: ts.SpreadElement): ExpressionVisitResult {
+        const innerExpression = this.transformExpression(expression.expression);
+
+        return this.createUnpackCall(innerExpression, expression);
+    }
+
     public transformStringLiteral(literal: ts.StringLiteralLike): tstl.StringLiteral {
         const text = this.escapeString(literal.text);
         return tstl.createStringLiteral(text);
@@ -2888,18 +2900,20 @@ export class LuaTransformer {
         return tstl.createCallExpression(tstl.createParenthesizedExpression(iife), [], undefined, tsOriginal);
     }
 
-    public createUnpackCall(expression: tstl.Expression): tstl.Expression {
+    public createUnpackCall(expression: tstl.Expression, tsOriginal: ts.Node): tstl.Expression {
         switch (this.options.luaTarget) {
             case LuaTarget.Lua51:
             case LuaTarget.LuaJIT:
-                return tstl.createCallExpression(tstl.createIdentifier("unpack"), [expression]);
+                return tstl.createCallExpression(tstl.createIdentifier("unpack"), [expression], undefined, tsOriginal);
 
             case LuaTarget.Lua52:
             case LuaTarget.Lua53:
             default:
                 return tstl.createCallExpression(
                     tstl.createTableIndexExpression(tstl.createIdentifier("table"), tstl.createStringLiteral("unpack")),
-                    [expression]
+                    [expression],
+                    undefined,
+                    tsOriginal
                 );
         }
     }
diff --git a/test/unit/spreadElement.spec.ts b/test/unit/spreadElement.spec.ts
@@ -20,25 +20,25 @@ export class SpreadElementTest {
     {
         // Cant test functional because our VM doesn't run on 5.1
         const lua = util.transpileString(`[].push(...${JSON.stringify([1, 2, 3])});`, {luaTarget: LuaTarget.Lua51});
-        Expect(lua).toBe("__TS__ArrayPush({}, unpack({1,2,3}));");
+        Expect(lua).toBe("__TS__ArrayPush({}, unpack({1, 2, 3}));");
     }
 
     @Test("Spread Element Lua 5.2")
     public spreadElement52(): void
     {
         const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.Lua52, luaLibImport: "none"});
-        Expect(lua).toBe("{table.unpack({0,1,2})};");
+        Expect(lua).toBe("{table.unpack({0, 1, 2})};");
     }
      @Test("Spread Element Lua 5.3")
     public spreadElement53(): void
     {
         const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.Lua53, luaLibImport: "none"});
-        Expect(lua).toBe("{table.unpack({0,1,2})};");
+        Expect(lua).toBe("{table.unpack({0, 1, 2})};");
     }
      @Test("Spread Element Lua JIT")
     public spreadElementJIT(): void
     {
         const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.LuaJIT, luaLibImport: "none"});
-        Expect(lua).toBe("{unpack({0,1,2})};");
+        Expect(lua).toBe("{unpack({0, 1, 2})};");
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -20,25 +20,25 @@ export class SpreadElementTest {`
`20`	`20`	`{`
`21`	`21`	`// Cant test functional because our VM doesn't run on 5.1`
`22`	`22`	const lua = util.transpileString(`[].push(...${JSON.stringify([1, 2, 3])});`, {luaTarget: LuaTarget.Lua51});
`23`		`- Expect(lua).toBe("__TS__ArrayPush({}, unpack({1,2,3}));");`
	`23`	`+ Expect(lua).toBe("__TS__ArrayPush({}, unpack({1, 2, 3}));");`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`@Test("Spread Element Lua 5.2")`
`27`	`27`	`public spreadElement52(): void`
`28`	`28`	`{`
`29`	`29`	const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.Lua52, luaLibImport: "none"});
`30`		`- Expect(lua).toBe("{table.unpack({0,1,2})};");`
	`30`	`+ Expect(lua).toBe("{table.unpack({0, 1, 2})};");`
`31`	`31`	`}`
`32`	`32`	`@Test("Spread Element Lua 5.3")`
`33`	`33`	`public spreadElement53(): void`
`34`	`34`	`{`
`35`	`35`	const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.Lua53, luaLibImport: "none"});
`36`		`- Expect(lua).toBe("{table.unpack({0,1,2})};");`
	`36`	`+ Expect(lua).toBe("{table.unpack({0, 1, 2})};");`
`37`	`37`	`}`
`38`	`38`	`@Test("Spread Element Lua JIT")`
`39`	`39`	`public spreadElementJIT(): void`
`40`	`40`	`{`
`41`	`41`	const lua = util.transpileString(`[...[0, 1, 2]]`, {luaTarget: LuaTarget.LuaJIT, luaLibImport: "none"});
`42`		`- Expect(lua).toBe("{unpack({0,1,2})};");`
	`42`	`+ Expect(lua).toBe("{unpack({0, 1, 2})};");`
`43`	`43`	`}`
`44`	`44`	`}`