TypeScriptToLua · Perryvw · Feb 7, 2018 · Feb 7, 2018 · Feb 7, 2018 · Feb 7, 2018
diff --git a/.gitignore b/.gitignore
@@ -1,6 +1,7 @@
 *.js
 node_modules/
 *.lua
+!json.lua
 !dist/*.js
 !dist/lualib/*.lua
 

diff --git a/dist/Transpiler.js b/dist/Transpiler.js
@@ -246,11 +246,11 @@ var LuaTranspiler = /** @class */ (function () {
         var identifier = variable.name;
         // Transpile expression
         var expression = this.transpileExpression(node.expression);
-        // Use ipairs for array types, pairs otherwise
-        var isArray = TSHelper_1.TSHelper.isArrayType(this.checker.getTypeAtLocation(node.expression));
-        var pairs = isArray ? "ipairs" : "pairs";
+        if (TSHelper_1.TSHelper.isArrayType(this.checker.getTypeAtLocation(node.expression))) {
+            throw new TranspileError("Iterating over arrays with 'for in' is not allowed.", node);
+        }
         // Make header
-        var result = this.indent + ("for " + identifier.escapedText + ", _ in " + pairs + "(" + expression + ") do\n");
+        var result = this.indent + ("for " + identifier.escapedText + ", _ in pairs(" + expression + ") do\n");
         // For body
         this.pushIndent();
         result += this.transpileStatement(node.statement);
@@ -561,6 +561,8 @@ var LuaTranspiler = /** @class */ (function () {
                 return "TS_slice(" + caller + ", " + params + ")";
             case "splice":
                 return "TS_splice(" + caller + ", " + params + ")";
+            case "join":
+                return "table.concat(" + caller + ", " + params + ")";
             default:
                 throw new TranspileError("Unsupported array function: " + expression.name.escapedText, node);
         }

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -9,6 +9,7 @@
         "coverage": "nyc --reporter=lcov npm test && nyc report"
     },
     "devDependencies": {
+        "deep-equal": "^1.0.1",
         "nyc": "^11.4.1"
     }
 }
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -274,7 +274,7 @@ export class LuaTranspiler {
         }
 
         // Make header
-        let result = this.indent + `for ${identifier.escapedText}, _ in "pairs"(${expression}) do\n`;
+        let result = this.indent + `for ${identifier.escapedText}, _ in pairs(${expression}) do\n`;
 
         // For body
         this.pushIndent();

diff --git a/test/integration/lua/loops.spec.ts b/test/integration/lua/loops.spec.ts
@@ -0,0 +1,83 @@
+import { Expect, Test, TestCase } from "alsatian";
+import * as util from "../../src/util"
+
+const deepEqual = require('deep-equal')
+
+export class LuaLoopTests {
+
+    @TestCase([0, 1, 2, 3], [1, 2, 3, 4])
+    @Test("for")
+    public for<T>(inp: T[], expected: T[]) {
+        // Transpile
+        let lua = util.transpileString(
+            `let arrTest = ${JSON.stringify(inp)};
+            for (let i = 0; i < arrTest.length; ++i) {
+                arrTest[i] = arrTest[i] + 1;
+            }
+            return JSONStringify(arrTest);`
+            , util.dummyTypes.Array
+        );
+
+        // Execute
+        let result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(JSON.stringify(expected));
+    }
+
+    @TestCase({ ['test1']: 0, ['test2']: 1, ['test3']: 2 }, { ['test1']: 1, ['test2']: 2, ['test3']: 3 })
+    @Test("forin[Object]")
+    public forinObject<T>(inp: any, expected: any) {
+        // Transpile
+        let lua = util.transpileString(
+            `let objTest = ${JSON.stringify(inp)};
+            for (let key in objTest) {
+                objTest[key] = objTest[key] + 1;
+            }
+            return JSONStringify(objTest);`
+            , util.dummyTypes.Object
+        );
+
+        // Execute
+        let result = util.executeLua(lua);
+
+        // Assert
+        Expect(deepEqual(JSON.parse(result), expected)).toBe(true);
+    }
+
+    @TestCase([1,2,3])
+    @Test("forin[Array]")
+    public forinArray<T>(inp: T[]) {
+        // Transpile & Assert
+        Expect(() => {
+            let lua = util.transpileString(
+                `let arrTest = ${JSON.stringify(inp)};
+                for (let key in arrTest) {
+                    arrTest[key]++;
+                }`
+                , util.dummyTypes.Array
+            );
+        }).toThrowError(Error, "Iterating over arrays with 'for in' is not allowed.");
+    }
+
+    @TestCase([0,1,2], [1,2,3])
+    @Test("forof")
+    public forof<T>(inp: any, expected: any) {
+        // Transpile
+        let lua = util.transpileString(
+            `let objTest = ${JSON.stringify(inp)};
+            let arrResultTest = {};
+            for (let value of objTest) {
+                arrResultTest.push(value + 1)
+            }
+            return JSONStringify(arrResultTest);`
+            , util.dummyTypes.Array
+        );
+
+        // Execute
+        let result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(JSON.stringify(expected));
+    }
+}