TypeScriptToLua · Perryvw · Sep 3, 2022 · Apr 16, 2022 · Apr 16, 2022 · Apr 16, 2022
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -5,6 +5,7 @@ module.exports = {
         project: [
             "test/tsconfig.json",
             "src/lualib/tsconfig.json",
+            "src/lualib/tsconfig.lua50.json",
             "benchmark/tsconfig.json",
             "language-extensions/tsconfig.json",
         ],

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -18,14 +18,14 @@
         "dist/**/*.js",
         "dist/**/*.lua",
         "dist/**/*.ts",
-        "dist/lualib/*.json",
+        "dist/lualib/**/*.json",
         "language-extensions/**/*.ts"
     ],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {
         "build": "tsc && npm run build-lualib",
-        "build-lualib": "node dist/tstl.js -p src/lualib/tsconfig.json",
+        "build-lualib": "node dist/tstl.js -p src/lualib/tsconfig.json && node dist/tstl.js -p src/lualib/tsconfig.lua50.json",
         "pretest": "npm run lint && npm run check:language-extensions && npm run build-lualib",
         "test": "jest",
         "lint": "npm run lint:eslint && npm run lint:prettier",
@@ -65,8 +65,8 @@
         "javascript-stringify": "^2.0.1",
         "jest": "^28.1.3",
         "jest-circus": "^29.0.1",
-        "lua-types": "^2.12.1",
-        "lua-wasm-bindings": "^0.2.2",
+        "lua-types": "^2.12.2",
+        "lua-wasm-bindings": "^0.3.1",
         "prettier": "^2.3.2",
         "ts-jest": "^28.0.8",
         "ts-node": "^10.9.1",

diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts
@@ -53,6 +53,7 @@ export enum LuaLibImportKind {
 
 export enum LuaTarget {
     Universal = "universal",
+    Lua50 = "5.0",
     Lua51 = "5.1",
     Lua52 = "5.2",
     Lua53 = "5.3",

diff --git a/src/LuaAST.ts b/src/LuaAST.ts
@@ -32,6 +32,7 @@ export enum SyntaxKind {
     NumericLiteral,
     NilKeyword,
     DotsKeyword,
+    ArgKeyword,
     TrueKeyword,
     FalseKeyword,
     FunctionExpression,
@@ -544,6 +545,18 @@ export function createDotsLiteral(tsOriginal?: ts.Node): DotsLiteral {
     return createNode(SyntaxKind.DotsKeyword, tsOriginal) as DotsLiteral;
 }
 
+export interface ArgLiteral extends Expression {
+    kind: SyntaxKind.ArgKeyword;
+}
+
+export function isArgLiteral(node: Node): node is ArgLiteral {
+    return node.kind === SyntaxKind.ArgKeyword;
+}
+
+export function createArgLiteral(tsOriginal?: ts.Node): ArgLiteral {
+    return createNode(SyntaxKind.ArgKeyword, tsOriginal) as ArgLiteral;
+}
+
 // StringLiteral / NumberLiteral
 // TODO TS uses the export interface "LiteralLikeNode" with a "text: string" member
 // but since we don't parse from text I think we can simplify by just having a value member
@@ -581,10 +594,11 @@ export function createStringLiteral(value: string, tsOriginal?: ts.Node): String
 
 export function isLiteral(
     node: Node
-): node is NilLiteral | DotsLiteral | BooleanLiteral | NumericLiteral | StringLiteral {
+): node is NilLiteral | DotsLiteral | ArgLiteral | BooleanLiteral | NumericLiteral | StringLiteral {
     return (
         isNilLiteral(node) ||
         isDotsLiteral(node) ||
+        isArgLiteral(node) ||
         isBooleanLiteral(node) ||
         isNumericLiteral(node) ||
         isStringLiteral(node)

diff --git a/src/LuaLib.ts b/src/LuaLib.ts
@@ -1,6 +1,7 @@
 import * as path from "path";
 import { EmitHost } from "./transpilation";
 import * as lua from "./LuaAST";
+import { LuaTarget } from "./CompilerOptions";
 
 export enum LuaLibFeature {
     ArrayConcat = "ArrayConcat",
@@ -34,6 +35,7 @@ export enum LuaLibFeature {
     Class = "Class",
     ClassExtends = "ClassExtends",
     CloneDescriptor = "CloneDescriptor",
+    CountVarargs = "CountVarargs",
     Decorate = "Decorate",
     DecorateParam = "DecorateParam",
     Delete = "Delete",
@@ -46,8 +48,11 @@ export enum LuaLibFeature {
     Iterator = "Iterator",
     LuaIteratorSpread = "LuaIteratorSpread",
     Map = "Map",
+    Match = "Match",
     MathAtan2 = "MathAtan2",
+    MathModf = "MathModf",
     MathSign = "MathSign",
+    Modulo50 = "Modulo50",
     New = "New",
     Number = "Number",
     NumberIsFinite = "NumberIsFinite",
@@ -107,23 +112,28 @@ export interface LuaLibFeatureInfo {
 }
 export type LuaLibModulesInfo = Record<LuaLibFeature, LuaLibFeatureInfo>;
 
+export function resolveLuaLibDir(luaTarget: LuaTarget) {
+    const luaLibDir = luaTarget === LuaTarget.Lua50 ? "5.0" : "universal";
+    return path.resolve(__dirname, path.join("..", "dist", "lualib", luaLibDir));
+}
+
 export const luaLibModulesInfoFileName = "lualib_module_info.json";
-let luaLibModulesInfo: LuaLibModulesInfo | undefined;
-export function getLuaLibModulesInfo(emitHost: EmitHost): LuaLibModulesInfo {
-    if (luaLibModulesInfo === undefined) {
-        const lualibPath = path.resolve(__dirname, `../dist/lualib/${luaLibModulesInfoFileName}`);
+const luaLibModulesInfo = new Map<string, LuaLibModulesInfo>();
+export function getLuaLibModulesInfo(luaTarget: LuaTarget, emitHost: EmitHost): LuaLibModulesInfo {
+    const lualibPath = path.join(resolveLuaLibDir(luaTarget), luaLibModulesInfoFileName);
+    if (!luaLibModulesInfo.has(lualibPath)) {
         const result = emitHost.readFile(lualibPath);
         if (result !== undefined) {
-            luaLibModulesInfo = JSON.parse(result) as LuaLibModulesInfo;
+            luaLibModulesInfo.set(lualibPath, JSON.parse(result) as LuaLibModulesInfo);
         } else {
             throw new Error(`Could not load lualib dependencies from '${lualibPath}'`);
         }
     }
-    return luaLibModulesInfo;
+    return luaLibModulesInfo.get(lualibPath) as LuaLibModulesInfo;
 }
 
-export function readLuaLibFeature(feature: LuaLibFeature, emitHost: EmitHost): string {
-    const featurePath = path.resolve(__dirname, `../dist/lualib/${feature}.lua`);
+export function readLuaLibFeature(feature: LuaLibFeature, luaTarget: LuaTarget, emitHost: EmitHost): string {
+    const featurePath = path.join(resolveLuaLibDir(luaTarget), `${feature}.lua`);
     const luaLibFeature = emitHost.readFile(featurePath);
     if (luaLibFeature === undefined) {
         throw new Error(`Could not load lualib feature from '${featurePath}'`);
@@ -133,8 +143,9 @@ export function readLuaLibFeature(feature: LuaLibFeature, emitHost: EmitHost): s
 
 export function resolveRecursiveLualibFeatures(
     features: Iterable<LuaLibFeature>,
+    luaTarget: LuaTarget,
     emitHost: EmitHost,
-    luaLibModulesInfo: LuaLibModulesInfo = getLuaLibModulesInfo(emitHost)
+    luaLibModulesInfo: LuaLibModulesInfo = getLuaLibModulesInfo(luaTarget, emitHost)
 ): LuaLibFeature[] {
     const loadedFeatures = new Set<LuaLibFeature>();
     const result: LuaLibFeature[] = [];
@@ -158,19 +169,27 @@ export function resolveRecursiveLualibFeatures(
     return result;
 }
 
-export function loadInlineLualibFeatures(features: Iterable<LuaLibFeature>, emitHost: EmitHost): string {
+export function loadInlineLualibFeatures(
+    features: Iterable<LuaLibFeature>,
+    luaTarget: LuaTarget,
+    emitHost: EmitHost
+): string {
     let result = "";
 
-    for (const feature of resolveRecursiveLualibFeatures(features, emitHost)) {
-        const luaLibFeature = readLuaLibFeature(feature, emitHost);
+    for (const feature of resolveRecursiveLualibFeatures(features, luaTarget, emitHost)) {
+        const luaLibFeature = readLuaLibFeature(feature, luaTarget, emitHost);
         result += luaLibFeature + "\n";
     }
 
     return result;
 }
 
-export function loadImportedLualibFeatures(features: Iterable<LuaLibFeature>, emitHost: EmitHost): lua.Statement[] {
-    const luaLibModuleInfo = getLuaLibModulesInfo(emitHost);
+export function loadImportedLualibFeatures(
+    features: Iterable<LuaLibFeature>,
+    luaTarget: LuaTarget,
+    emitHost: EmitHost
+): lua.Statement[] {
+    const luaLibModuleInfo = getLuaLibModulesInfo(luaTarget, emitHost);
 
     const imports = Array.from(features).flatMap(feature => luaLibModuleInfo[feature].exports);
 
@@ -196,17 +215,17 @@ export function loadImportedLualibFeatures(features: Iterable<LuaLibFeature>, em
     return statements;
 }
 
-let luaLibBundleContent: string;
-export function getLuaLibBundle(emitHost: EmitHost): string {
-    if (luaLibBundleContent === undefined) {
-        const lualibPath = path.resolve(__dirname, "../dist/lualib/lualib_bundle.lua");
+const luaLibBundleContent = new Map<string, string>();
+export function getLuaLibBundle(luaTarget: LuaTarget, emitHost: EmitHost): string {
+    const lualibPath = path.join(resolveLuaLibDir(luaTarget), "lualib_bundle.lua");
+    if (!luaLibBundleContent.has(lualibPath)) {
         const result = emitHost.readFile(lualibPath);
         if (result !== undefined) {
-            luaLibBundleContent = result;
+            luaLibBundleContent.set(lualibPath, result);
         } else {
             throw new Error(`Could not load lualib bundle from '${lualibPath}'`);
         }
     }
 
-    return luaLibBundleContent;
+    return luaLibBundleContent.get(lualibPath) as string;
 }
diff --git a/src/LuaPrinter.ts b/src/LuaPrinter.ts
@@ -1,7 +1,7 @@
 import * as path from "path";
 import { Mapping, SourceMapGenerator, SourceNode } from "source-map";
 import * as ts from "typescript";
-import { CompilerOptions, isBundleEnabled, LuaLibImportKind } from "./CompilerOptions";
+import { CompilerOptions, isBundleEnabled, LuaLibImportKind, LuaTarget } from "./CompilerOptions";
 import * as lua from "./LuaAST";
 import { loadInlineLualibFeatures, LuaLibFeature, loadImportedLualibFeatures } from "./LuaLib";
 import { isValidLuaIdentifier, shouldAllowUnicode } from "./transformation/utils/safe-names";
@@ -233,14 +233,17 @@ export class LuaPrinter {
             sourceChunks.push(tstlHeader);
         }
 
+        const luaTarget = this.options.luaTarget ?? LuaTarget.Universal;
         const luaLibImport = this.options.luaLibImport ?? LuaLibImportKind.Require;
         if (luaLibImport === LuaLibImportKind.Require && file.luaLibFeatures.size > 0) {
             // Import lualib features
-            sourceChunks = this.printStatementArray(loadImportedLualibFeatures(file.luaLibFeatures, this.emitHost));
+            sourceChunks = this.printStatementArray(
+                loadImportedLualibFeatures(file.luaLibFeatures, luaTarget, this.emitHost)
+            );
         } else if (luaLibImport === LuaLibImportKind.Inline && file.luaLibFeatures.size > 0) {
             // Inline lualib features
             sourceChunks.push("-- Lua Library inline imports\n");
-            sourceChunks.push(loadInlineLualibFeatures(file.luaLibFeatures, this.emitHost));
+            sourceChunks.push(loadInlineLualibFeatures(file.luaLibFeatures, luaTarget, this.emitHost));
             sourceChunks.push("-- End of Lua Library inline imports\n");
         }
 
@@ -583,6 +586,8 @@ export class LuaPrinter {
                 return this.printNilLiteral(expression as lua.NilLiteral);
             case lua.SyntaxKind.DotsKeyword:
                 return this.printDotsLiteral(expression as lua.DotsLiteral);
+            case lua.SyntaxKind.ArgKeyword:
+                return this.printArgLiteral(expression as lua.ArgLiteral);
             case lua.SyntaxKind.TrueKeyword:
             case lua.SyntaxKind.FalseKeyword:
                 return this.printBooleanLiteral(expression as lua.BooleanLiteral);
@@ -625,6 +630,10 @@ export class LuaPrinter {
         return this.createSourceNode(expression, "...");
     }
 
+    public printArgLiteral(expression: lua.ArgLiteral): SourceNode {
+        return this.createSourceNode(expression, "arg");
+    }
+
     public printBooleanLiteral(expression: lua.BooleanLiteral): SourceNode {
         return this.createSourceNode(expression, expression.kind === lua.SyntaxKind.TrueKeyword ? "true" : "false");
     }

diff --git a/src/lualib-build/plugin.ts b/src/lualib-build/plugin.ts
@@ -42,12 +42,23 @@ class LuaLibPlugin implements tstl.Plugin {
             emitBOM
         );
 
+        // Flatten the output folder structure; we do not want to keep the target-specific directories
+        for (const file of result) {
+            let outPath = file.fileName;
+            while (outPath.includes("lualib") && path.basename(path.dirname(outPath)) !== "lualib") {
+                const upOne = path.join(path.dirname(outPath), "..", path.basename(outPath));
+                outPath = path.normalize(upOne);
+            }
+            file.fileName = outPath;
+        }
+
         // Create map of result files keyed by their 'lualib name'
         const exportedLualibFeatures = new Map(result.map(f => [path.basename(f.fileName).split(".")[0], f.code]));
 
         // Figure out the order required in the bundle by recursively resolving all dependency features
         const allFeatures = Object.values(LuaLibFeature) as LuaLibFeature[];
-        const orderedFeatures = resolveRecursiveLualibFeatures(allFeatures, emitHost, luaLibModuleInfo);
+        const luaTarget = options.luaTarget ?? tstl.LuaTarget.Universal;
+        const orderedFeatures = resolveRecursiveLualibFeatures(allFeatures, luaTarget, emitHost, luaLibModuleInfo);
 
         // Concatenate lualib files into bundle with exports table and add lualib_bundle.lua to results
         let lualibBundle = orderedFeatures.map(f => exportedLualibFeatures.get(LuaLibFeature[f])).join("\n");

diff --git a/src/lualib/5.0/CountVarargs.ts b/src/lualib/5.0/CountVarargs.ts
@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+
+export function __TS__CountVarargs<T>(...args: T[]): number {
+    // select() is not available in Lua 5.0. In this version, the arg table
+    // includes trailing nils.
+    return args.length;
+}