Limit unpack call in destructuring assignments to only required elements (#1655)

Author: Perryvw

src/transformation/utils/lua-ast.ts

@@ -81,6 +81,35 @@ export function createUnpackCall(
     return lua.setNodeFlags(lua.createCallExpression(unpack, [expression], tsOriginal), lua.NodeFlags.TableUnpackCall);
 }
 
+export function createBoundedUnpackCall(
+    context: TransformationContext,
+    expression: lua.Expression,
+    maxUnpackItem: number,
+    tsOriginal?: ts.Node
+): lua.Expression {
+    if (context.luaTarget === LuaTarget.Universal) {
+        return transformLuaLibFunction(context, LuaLibFeature.Unpack, tsOriginal, expression);
+    }
+
+    // Lua 5.0 does not support this signature, so don't add the arguments there
+    const extraArgs =
+        context.luaTarget === LuaTarget.Lua50
+            ? []
+            : [lua.createNumericLiteral(1), lua.createNumericLiteral(maxUnpackItem)];
+
+    const unpack =
+        context.luaTarget === LuaTarget.Lua50 ||
+        context.luaTarget === LuaTarget.Lua51 ||
+        context.luaTarget === LuaTarget.LuaJIT
+            ? lua.createIdentifier("unpack")
+            : lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("unpack"));
+
+    return lua.setNodeFlags(
+        lua.createCallExpression(unpack, [expression, ...extraArgs], tsOriginal),
+        lua.NodeFlags.TableUnpackCall
+    );
+}
+
 export function isUnpackCall(node: lua.Node): boolean {
     return lua.isCallExpression(node) && (node.flags & lua.NodeFlags.TableUnpackCall) !== 0;
 }

src/transformation/visitors/binary-expression/assignments.ts

@@ -4,7 +4,7 @@ import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
 import { validateAssignment } from "../../utils/assignment-validation";
 import { createExportedIdentifier, getDependenciesOfSymbol, isSymbolExported } from "../../utils/export";
-import { createUnpackCall, wrapInTable } from "../../utils/lua-ast";
+import { createBoundedUnpackCall, wrapInTable } from "../../utils/lua-ast";
 import { LuaLibFeature, transformLuaLibFunction } from "../../utils/lualib";
 import { isArrayType, isDestructuringAssignment } from "../../utils/typescript";
 import { isArrayLength, transformDestructuringAssignment } from "./destructuring-assignments";
@@ -252,7 +252,7 @@ export function transformAssignmentStatement(
             } else {
                 right = context.transformExpression(expression.right);
                 if (!isMultiReturnCall(context, expression.right) && isArrayType(context, rightType)) {
-                    right = createUnpackCall(context, right, expression.right);
+                    right = createBoundedUnpackCall(context, right, expression.left.elements.length, expression.right);
                 }
             }
 

src/transformation/visitors/variable-declaration.ts

@@ -5,7 +5,7 @@ import { FunctionVisitor, TransformationContext } from "../context";
 import { validateAssignment } from "../utils/assignment-validation";
 import { unsupportedVarDeclaration } from "../utils/diagnostics";
 import { addExportToIdentifier } from "../utils/export";
-import { createLocalOrExportedOrGlobalDeclaration, createUnpackCall, wrapInTable } from "../utils/lua-ast";
+import { createBoundedUnpackCall, createLocalOrExportedOrGlobalDeclaration, wrapInTable } from "../utils/lua-ast";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { transformInPrecedingStatementScope } from "../utils/preceding-statements";
 import { createCallableTable, isFunctionTypeWithProperties } from "./function";
@@ -209,10 +209,11 @@ export function transformBindingVariableDeclaration(
                     : lua.createNilLiteral();
             statements.push(...createLocalOrExportedOrGlobalDeclaration(context, vars, values, initializer));
         } else {
-            // local vars = this.transpileDestructingAssignmentValue(node.initializer);
-            const unpackedInitializer = createUnpackCall(
+            // use unpack(thing, 1, #bindingItems) to unpack
+            const unpackedInitializer = createBoundedUnpackCall(
                 context,
                 context.transformExpression(initializer),
+                bindingPattern.elements.length,
                 initializer
             );
             statements.push(

test/unit/destructuring.spec.ts

@@ -195,6 +195,17 @@ describe("array destructuring optimization", () => {
             .expectToMatchJsResult();
     });
 
+    util.testEachVersion(
+        "array versions",
+        () =>
+            util.testFunction`
+            const array = [3, 5, 1];
+            const [a, b, c] = array;
+            return { a, b, c };
+        `,
+        util.expectEachVersionExceptJit(builder => builder.expectToMatchJsResult())
+    );
+
     test("array literal", () => {
         util.testFunction`
             const [a, b, c] = [3, 5, 1];