TypeScriptToLua
diff --git a/‎src/TSHelper.ts‎
Lines changed: 9 additions & 0 deletions b/‎src/TSHelper.ts‎
Lines changed: 9 additions & 0 deletions
diff --git a/‎src/Transpiler.ts‎
Lines changed: 21 additions & 7 deletions b/‎src/Transpiler.ts‎
Lines changed: 21 additions & 7 deletions
diff --git a/‎test/unit/assignments.spec.ts‎
Lines changed: 5 additions & 4 deletions b/‎test/unit/assignments.spec.ts‎
Lines changed: 5 additions & 4 deletions
@@ -80,6 +80,15 @@ export class TSHelper {
             && this.hasCustomDecorator(type, checker, "!Phantom");
     }
 
+    public static isTupleReturnCall(node: ts.Node, checker: ts.TypeChecker): boolean {
+        if (ts.isCallExpression(node)) {
+            const type = checker.getTypeAtLocation(node.expression);
+            return this.isTupleReturnFunction(type, checker);
+        } else {
+            return false;
+        }
+    }
+
     public static isTupleReturnFunction(type: ts.Type, checker: ts.TypeChecker): boolean {
         return type.symbol
             && ((type.symbol.flags & ts.SymbolFlags.Function) !== 0
 
@@ -798,10 +798,19 @@ export class LuaTranspiler {
                     result = `${lhs}<=${rhs}`;
                     break;
                 case ts.SyntaxKind.EqualsToken:
+                    let assignmentValue = rhs;
+                    // If the right-hand side of the equation is a tuple return method
+                    // and the left-hand side is not a destructing statement, wrap the
+                    // rhs in { }.
+                    if (ts.isIdentifier(node.left) && tsHelper.isTupleReturnCall(node.right, this.checker)) {
+                        assignmentValue = `{ ${rhs} }`;
+                    }
+
                     if (tsHelper.hasSetAccessor(node.left, this.checker)) {
-                        return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, rhs);
+                        return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, assignmentValue);
                     }
-                    result = `${lhs}=${rhs}`;
+
+                    result = `${lhs}=${assignmentValue}`;
                     break;
                 case ts.SyntaxKind.EqualsEqualsToken:
                 case ts.SyntaxKind.EqualsEqualsEqualsToken:
@@ -1176,7 +1185,15 @@ export class LuaTranspiler {
             const identifier = node.name;
             if (node.initializer) {
                 const value = this.transpileExpression(node.initializer);
-                return `local ${identifier.escapedText} = ${value}\n`;
+
+                // If the right-hand side of the equation is a tuple return method
+                // and the left-hand side is not a destructing statement, wrap the
+                // rhs in { }.
+                if (tsHelper.isTupleReturnCall(node.initializer, this.checker)) {
+                    return `local ${identifier.escapedText} = { ${value} }\n`;
+                } else {
+                    return `local ${identifier.escapedText} = ${value}\n`;
+                }
             } else {
                 return `local ${identifier.escapedText} = nil\n`;
             }
@@ -1194,10 +1211,7 @@ export class LuaTranspiler {
                 ).escapedText).join(",");
 
             // Don't unpack TupleReturn decorated functions
-            if (ts.isCallExpression(node.initializer)
-                && tsHelper.isTupleReturnFunction(this.checker.getTypeAtLocation(node.initializer.expression),
-                                                  this.checker)
-               ) {
+            if (tsHelper.isTupleReturnCall(node.initializer, this.checker)) {
                 return `local ${vars}=${value}\n`;
             } else {
                 return `local ${vars}=table.unpack(${value})\n`;
 
@@ -1,4 +1,4 @@
-import { Expect, Test, TestCase, FocusTest } from "alsatian";
+import { Expect, Test, TestCase } from "alsatian";
 import { TranspileError } from "../../src/Transpiler";
 
 import * as util from "../src/util";
@@ -87,11 +87,12 @@ export class AssignmentTests {
     @Test("TupleReturn Single assignment")
     public tupleReturnSingleAssignment() {
         const code = `/** !TupleReturn */\n`
-                   + `declare function abc() { return [1,2,3]; }\n`
-                   + `let a = abc();`;
+                   + `declare function abc(): [number, string]; }\n`
+                   + `let a = abc();`
+                   + `a = abc();`;
 
         const lua = util.transpileString(code);
-        Expect(lua).toBe("local a = abc()");
+        Expect(lua).toBe("local a = { abc() }\n\na={ abc() }");
     }
 
     @Test("TupleReturn interface assignment")