TypeScriptToLua · Perryvw · Jan 3, 2019 · Dec 30, 2018 · Dec 31, 2018 · Dec 31, 2018
diff --git a/build_lualib.ts b/build_lualib.ts
@@ -1,6 +1,7 @@
 import * as fs from "fs";
 import * as glob from "glob";
 import {compile} from "./src/Compiler";
+import {LuaLib as luaLib, LuaLibFeature} from "./src/LuaLib";
 
 const bundlePath = "./dist/lualib/lualib_bundle.lua";
 
@@ -15,14 +16,11 @@ compile([
     "--rootDir",
     "./src/lualib",
     ...glob.sync("./src/lualib/*.ts"),
-  ]);
+]);
 
 if (fs.existsSync(bundlePath)) {
-  fs.unlinkSync(bundlePath);
+    fs.unlinkSync(bundlePath);
 }
 
-let bundle = "";
-
-glob.sync("./dist/lualib/*.lua").forEach(fileName => bundle += fs.readFileSync(fileName));
-
+const bundle = luaLib.loadFeatures(Object.keys(LuaLibFeature).map(lib => LuaLibFeature[lib]));
 fs.writeFileSync(bundlePath, bundle);
diff --git a/src/Decorator.ts b/src/Decorator.ts
@@ -14,6 +14,7 @@ export class Decorator {
             case "phantom": return DecoratorKind.Phantom;
             case "tuplereturn": return DecoratorKind.TupleReturn;
             case "noclassor": return DecoratorKind.NoClassOr;
+            case "luaiterator": return DecoratorKind.LuaIterator;
         }
 
         return undefined;
@@ -37,4 +38,5 @@ export enum DecoratorKind {
     Phantom = "Phantom",
     TupleReturn = "TupleReturn",
     NoClassOr = "NoClassOr",
+    LuaIterator = "LuaIterator",
 }
diff --git a/src/Errors.ts b/src/Errors.ts
@@ -109,4 +109,11 @@ export class TSTLErrors {
                                       node);
         }
     }
+
+    public static UnsupportedNonDestructuringLuaIterator = (node: ts.Node) => {
+        return new TranspileError("Unsupported use of lua iterator with TupleReturn decorator in for...of statement. "
+                                  + "You must use a destructuring statement to catch results from a lua iterator with "
+                                  + "the TupleReturn decorator.",
+                                  node);
+    }
 }
diff --git a/src/LuaLib.ts b/src/LuaLib.ts
@@ -0,0 +1,60 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export enum LuaLibFeature {
+    ArrayConcat = "ArrayConcat",
+    ArrayEvery = "ArrayEvery",
+    ArrayFilter = "ArrayFilter",
+    ArrayForEach = "ArrayForEach",
+    ArrayIndexOf = "ArrayIndexOf",
+    ArrayMap = "ArrayMap",
+    ArrayPush = "ArrayPush",
+    ArrayReverse = "ArrayReverse",
+    ArrayShift = "ArrayShift",
+    ArrayUnshift = "ArrayUnshift",
+    ArraySort = "ArraySort",
+    ArraySlice = "ArraySlice",
+    ArraySome = "ArraySome",
+    ArraySplice = "ArraySplice",
+    FunctionApply = "FunctionApply",
+    FunctionBind = "FunctionBind",
+    FunctionCall = "FunctionCall",
+    InstanceOf = "InstanceOf",
+    Iterator = "Iterator",
+    Map = "Map",
+    Set = "Set",
+    StringReplace = "StringReplace",
+    StringSplit = "StringSplit",
+    Symbol = "Symbol",
+    Ternary = "Ternary",
+}
+
+const luaLibDependencies: { [lib in LuaLibFeature]?: LuaLibFeature[] } = {
+    Iterator: [LuaLibFeature.Symbol],
+    Map: [LuaLibFeature.InstanceOf, LuaLibFeature.Iterator, LuaLibFeature.Symbol],
+    Set: [LuaLibFeature.InstanceOf, LuaLibFeature.Iterator, LuaLibFeature.Symbol],
+};
+
+export class LuaLib {
+    public static loadFeatures(features: Iterable<LuaLibFeature>): string {
+        let result = "";
+
+        const loadedFeatures = new Set<LuaLibFeature>();
+
+        function load(feature: LuaLibFeature): void {
+            if (!loadedFeatures.has(feature)) {
+                loadedFeatures.add(feature);
+                if (luaLibDependencies[feature]) {
+                    luaLibDependencies[feature].forEach(load);
+                }
+                const featureFile = path.resolve(__dirname, `../dist/lualib/${feature}.lua`);
+                result += fs.readFileSync(featureFile).toString() + "\n";
+            }
+        }
+
+        for (const feature of features) {
+            load(feature);
+        }
+        return result;
+    }
+}
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -138,6 +138,16 @@ export class TSHelper {
         return this.forTypeOrAnySupertype(type, checker, t => this.isExplicitArrayType(t, checker));
     }
 
+    public static isLuaIteratorCall(node: ts.Node, checker: ts.TypeChecker): boolean {
+        if (ts.isCallExpression(node) && node.parent && ts.isForOfStatement(node.parent)) {
+            const type = checker.getTypeAtLocation(node.expression);
+            return this.getCustomDecorators(type, checker)
+                       .has(DecoratorKind.LuaIterator);
+        } else {
+            return false;
+        }
+    }
+
     public static isTupleReturnCall(node: ts.Node, checker: ts.TypeChecker): boolean {
         if (ts.isCallExpression(node)) {
             const type = checker.getTypeAtLocation(node.expression);
@@ -157,7 +167,9 @@ export class TSHelper {
                 checker.getTypeAtLocation(declaration),
                 checker
             );
-            return decorators.has(DecoratorKind.TupleReturn);
+            return decorators.has(DecoratorKind.TupleReturn)
+                // Lua iterators are not 'true' tupleReturn functions as they actually return a function
+                && !decorators.has(DecoratorKind.LuaIterator);
         } else {
             return false;
         }