TypeScriptToLua · tomblind · Jun 13, 2019 · Jun 9, 2019 · Jun 10, 2019 · Jun 10, 2019
diff --git a/src/Decorator.ts b/src/Decorator.ts
@@ -29,6 +29,8 @@ export class Decorator {
                 return DecoratorKind.NoSelf;
             case "noselfinfile":
                 return DecoratorKind.NoSelfInFile;
+            case "vararg":
+                return DecoratorKind.Vararg;
             case "forrange":
                 return DecoratorKind.ForRange;
         }
@@ -63,5 +65,6 @@ export enum DecoratorKind {
     LuaTable = "LuaTable",
     NoSelf = "NoSelf",
     NoSelfInFile = "NoSelfInFile",
+    Vararg = "Vararg",
     ForRange = "ForRange",
 }
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -25,14 +25,14 @@ interface SymbolInfo {
 }
 
 interface FunctionDefinitionInfo {
-    referencedSymbols: Set<tstl.SymbolId>;
+    referencedSymbols: Map<tstl.SymbolId, ts.Node[]>;
     definition?: tstl.VariableDeclarationStatement | tstl.AssignmentStatement;
 }
 
 interface Scope {
     type: ScopeType;
     id: number;
-    referencedSymbols?: Set<tstl.SymbolId>;
+    referencedSymbols?: Map<tstl.SymbolId, ts.Node[]>;
     variableDeclarations?: tstl.VariableDeclarationStatement[];
     functionDefinitions?: Map<tstl.SymbolId, FunctionDefinitionInfo>;
     importStatements?: tstl.Statement[];
@@ -1388,12 +1388,31 @@ export class LuaTransformer {
         return [paramNames, dotsLiteral, restParamName];
     }
 
+    protected isRestParameterReferenced(identifier: tstl.Identifier, scope: Scope): boolean {
+        if (!identifier.symbolId) {
+            return true;
+        }
+        if (scope.referencedSymbols === undefined) {
+            return false;
+        }
+        const references = scope.referencedSymbols.get(identifier.symbolId);
+        if (!references) {
+            return false;
+        }
+        // Ignore references to @vararg types in spread elements
+        return references.some(
+            r => !r.parent || !ts.isSpreadElement(r.parent) || !tsHelper.isVarArgType(r, this.checker)
+        );
+    }
+
     protected transformFunctionBody(
         parameters: ts.NodeArray<ts.ParameterDeclaration>,
         body: ts.Block,
         spreadIdentifier?: tstl.Identifier
     ): [tstl.Statement[], Scope] {
         this.pushScope(ScopeType.Function);
+        const bodyStatements = this.performHoisting(this.transformStatements(body.statements));
+        const scope = this.popScope();
 
         const headerStatements = [];
 
@@ -1426,18 +1445,14 @@ export class LuaTransformer {
         }
 
         // Push spread operator here
-        if (spreadIdentifier) {
+        if (spreadIdentifier && this.isRestParameterReferenced(spreadIdentifier, scope)) {
             const spreadTable = this.wrapInTable(tstl.createDotsLiteral());
             headerStatements.push(tstl.createVariableDeclarationStatement(spreadIdentifier, spreadTable));
         }
 
         // Binding pattern statements need to be after spread table is declared
         headerStatements.push(...bindingPatternDeclarations);
 
-        const bodyStatements = this.performHoisting(this.transformStatements(body.statements));
-
-        const scope = this.popScope();
-
         return [headerStatements.concat(bodyStatements), scope];
     }
 
@@ -1844,7 +1859,7 @@ export class LuaTransformer {
             if (!scope.functionDefinitions) {
                 scope.functionDefinitions = new Map();
             }
-            const functionInfo = { referencedSymbols: functionScope.referencedSymbols || new Set() };
+            const functionInfo = { referencedSymbols: functionScope.referencedSymbols || new Map() };
             scope.functionDefinitions.set(name.symbolId, functionInfo);
         }
         return this.createLocalOrExportedOrGlobalDeclaration(name, functionExpression, functionDeclaration);
@@ -4603,6 +4618,10 @@ export class LuaTransformer {
             return innerExpression;
         }
 
+        if (ts.isIdentifier(expression.expression) && tsHelper.isVarArgType(expression.expression, this.checker)) {
+            return tstl.createDotsLiteral(expression);
+        }
+
         const type = this.checker.getTypeAtLocation(expression.expression);
         if (tsHelper.isArrayType(type, this.checker, this.program)) {
             return this.createUnpackCall(innerExpression, expression);
@@ -5278,13 +5297,20 @@ export class LuaTransformer {
                 if (declaration && identifier.pos < declaration.pos) {
                     throw TSTLErrors.ReferencedBeforeDeclaration(identifier);
                 }
-            } else if (symbolId !== undefined) {
+            }
+
+            if (symbolId !== undefined) {
                 //Mark symbol as seen in all current scopes
                 for (const scope of this.scopeStack) {
                     if (!scope.referencedSymbols) {
-                        scope.referencedSymbols = new Set();
+                        scope.referencedSymbols = new Map();
+                    }
+                    let references = scope.referencedSymbols.get(symbolId);
+                    if (!references) {
+                        references = [];
+                        scope.referencedSymbols.set(symbolId, references);
                     }
-                    scope.referencedSymbols.add(symbolId);
+                    references.push(identifier);
                 }
             }
         }

diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -184,6 +184,23 @@ export class TSHelper {
         return TSHelper.getCustomDecorators(type, checker).has(DecoratorKind.LuaIterator);
     }
 
+    public static isRestParameter(node: ts.Node, checker: ts.TypeChecker): boolean {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (!symbol) {
+            return false;
+        }
+        const declarations = symbol.getDeclarations();
+        if (!declarations) {
+            return false;
+        }
+        return declarations.some(d => ts.isParameter(d) && d.dotDotDotToken !== undefined);
+    }
+
+    public static isVarArgType(node: ts.Node, checker: ts.TypeChecker): boolean {
+        const type = checker.getTypeAtLocation(node);
+        return type !== undefined && TSHelper.getCustomDecorators(type, checker).has(DecoratorKind.Vararg);
+    }
+
     public static isForRangeType(node: ts.Node, checker: ts.TypeChecker): boolean {
         const type = checker.getTypeAtLocation(node);
         return TSHelper.getCustomDecorators(type, checker).has(DecoratorKind.ForRange);

diff --git a/test/translation/__snapshots__/transformation.spec.ts.snap b/test/translation/__snapshots__/transformation.spec.ts.snap
@@ -256,6 +256,7 @@ end"
 exports[`Transformation (functionRestArguments) 1`] = `
 "function varargsFunction(self, a, ...)
     local b = ({...})
+    local c = b
 end"
 `;
 
@@ -319,7 +320,6 @@ end
 function MyClass.prototype.____constructor(self)
 end
 function MyClass.prototype.varargsFunction(self, a, ...)
-    local b = ({...})
 end"
 `;
 

diff --git a/test/translation/transformation/functionRestArguments.ts b/test/translation/transformation/functionRestArguments.ts
@@ -1 +1,3 @@
-function varargsFunction(a: string, ...b: string[]): void {}
+function varargsFunction(a: string, ...b: string[]): void {
+    const c = b;
+}
diff --git a/test/unit/functions.spec.ts b/test/unit/functions.spec.ts
@@ -504,3 +504,109 @@ test("Function rest binding pattern", () => {
 
     expect(result).toBe("defxyzabc");
 });
+
+test.each([{}, { noHoisting: true }])("Function rest parameter", compilerOptions => {
+    const code = `
+        function foo(a: unknown, ...b: string[]) {
+            return b.join("");
+        }
+        return foo("A", "B", "C", "D");
+    `;
+
+    expect(util.transpileAndExecute(code, compilerOptions)).toBe("BCD");
+});
+
+test.each([{}, { noHoisting: true }])("Function nested rest parameter", compilerOptions => {
+    const code = `
+        function foo(a: unknown, ...b: string[]) {
+            function bar() {
+                return b.join("");
+            }
+            return bar();
+        }
+        return foo("A", "B", "C", "D");
+    `;
+
+    expect(util.transpileAndExecute(code, compilerOptions)).toBe("BCD");
+});
+
+test.each([{}, { noHoisting: true }])("Function nested rest spread", compilerOptions => {
+    const code = `
+        function foo(a: unknown, ...b: string[]) {
+            function bar() {
+                const c = [...b];
+                return c.join("");
+            }
+            return bar();
+        }
+        return foo("A", "B", "C", "D");
+    `;
+
+    expect(util.transpileAndExecute(code, compilerOptions)).toBe("BCD");
+});
+
+test.each([{}, { noHoisting: true }])("Function rest parameter (unreferenced)", compilerOptions => {
+    const code = `
+        function foo(a: unknown, ...b: string[]) {
+            return "foobar";
+        }
+        return foo("A", "B", "C", "D");
+    `;
+
+    expect(util.transpileString(code, compilerOptions)).not.toMatch("b = ({...})");
+    expect(util.transpileAndExecute(code, compilerOptions)).toBe("foobar");
+});
+
+test.each([{}, { noHoisting: true }])("@vararg", compilerOptions => {
+    const code = `
+        /** @vararg */ type LuaVarArg<A extends unknown[]> = A & { __luaVarArg?: never };
+        function foo(a: unknown, ...b: LuaVarArg<unknown[]>) {
+            const c = [...b];
+            return c.join("");
+        }
+        function bar(a: unknown, ...b: LuaVarArg<unknown[]>) {
+            return foo(a, ...b);
+        }
+        return bar("A", "B", "C", "D");
+    `;
+
+    const lua = util.transpileString(code, compilerOptions);
+    expect(lua).not.toMatch("b = ({...})");
+    expect(lua).not.toMatch("unpack");
+    expect(util.transpileAndExecute(code, compilerOptions)).toBe("BCD");
+});
+
+test.each([{}, { noHoisting: true }])("@vararg array access", compilerOptions => {
+    const code = `
+        /** @vararg */ type LuaVarArg<A extends unknown[]> = A & { __luaVarArg?: never };
+        function foo(a: unknown, ...b: LuaVarArg<unknown[]>) {
+            const c = [...b];
+            return c.join("") + b[0];
+        }
+        return foo("A", "B", "C", "D");
+    `;
+
+    expect(util.transpileAndExecute(code, compilerOptions)).toBe("BCDB");
+});
+
+test.each([{}, { noHoisting: true }])("@vararg global", compilerOptions => {
+    const code = `
+        /** @vararg */ type LuaVarArg<A extends unknown[]> = A & { __luaVarArg?: never };
+        declare const arg: LuaVarArg<string[]>;
+        const arr = [...arg];
+        const result = arr.join("");
+    `;
+
+    const luaBody = util.transpileString(code, compilerOptions, false);
+    expect(luaBody).not.toMatch("unpack");
+
+    const lua = `
+        function test(...)
+            ${luaBody}
+            return result
+        end
+        return test("A", "B", "C", "D")
+    `;
+
+    expect(util.executeLua(lua)).toBe("ABCD");
+});