TypeScriptToLua · Perryvw · Jul 31, 2019 · May 28, 2019 · May 28, 2019 · May 28, 2019
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -4552,7 +4552,7 @@ export class LuaTransformer {
                 return tstl.createNumericLiteral(Math[name], identifier);
 
             default:
-                throw TSTLErrors.UnsupportedProperty("math", name, identifier);
+                throw TSTLErrors.UnsupportedProperty("Math", name, identifier);
         }
     }
 
@@ -4622,7 +4622,7 @@ export class LuaTransformer {
             }
 
             default:
-                throw TSTLErrors.UnsupportedProperty("math", expressionName, expression);
+                throw TSTLErrors.UnsupportedProperty("Math", expressionName, expression);
         }
     }
 
@@ -4872,11 +4872,7 @@ export class LuaTransformer {
                     tstl.createStringLiteral("char")
                 );
             default:
-                throw TSTLErrors.UnsupportedForTarget(
-                    `string property ${identifierString}`,
-                    this.luaTarget,
-                    identifier
-                );
+                throw TSTLErrors.UnsupportedProperty("String", identifierString, identifier);
         }
     }
 
@@ -4898,7 +4894,7 @@ export class LuaTransformer {
             case "values":
                 return this.transformLuaLibFunction(LuaLibFeature.ObjectValues, expression, ...parameters);
             default:
-                throw TSTLErrors.UnsupportedForTarget(`object property ${methodName}`, this.luaTarget, expression);
+                throw TSTLErrors.UnsupportedProperty("Object", methodName, expression);
         }
     }
 
@@ -4969,7 +4965,7 @@ export class LuaTransformer {
                 );
                 return tstl.createCallExpression(tstl.createIdentifier("print"), [debugTracebackCall]);
             default:
-                throw TSTLErrors.UnsupportedForTarget(`console property ${methodName}`, this.luaTarget, expression);
+                throw TSTLErrors.UnsupportedProperty("console", methodName, expression);
         }
     }
 
@@ -4992,7 +4988,7 @@ export class LuaTransformer {
                 const functionIdentifier = tstl.createIdentifier(`__TS__SymbolRegistry${upperMethodName}`);
                 return tstl.createCallExpression(functionIdentifier, parameters, expression);
             default:
-                throw TSTLErrors.UnsupportedForTarget(`symbol property ${methodName}`, this.luaTarget, expression);
+                throw TSTLErrors.UnsupportedProperty("Symbol", methodName, expression);
         }
     }
 
@@ -5008,7 +5004,7 @@ export class LuaTransformer {
             case "isFinite":
                 return this.transformLuaLibFunction(LuaLibFeature.NumberIsFinite, expression, ...parameters);
             default:
-                throw TSTLErrors.UnsupportedForTarget(`number property ${methodName}`, this.luaTarget, expression);
+                throw TSTLErrors.UnsupportedProperty("Number", methodName, expression);
         }
     }
 
@@ -5186,11 +5182,14 @@ export class LuaTransformer {
     }
 
     public transformAssertionExpression(expression: ts.AssertionExpression): ExpressionVisitResult {
-        this.validateFunctionAssignment(
-            expression,
-            this.checker.getTypeAtLocation(expression.expression),
-            this.checker.getTypeAtLocation(expression.type)
-        );
+        if (!ts.isConstTypeReference(expression.type)) {
+            this.validateFunctionAssignment(
+                expression,
+                this.checker.getTypeAtLocation(expression.expression),
+                this.checker.getTypeAtLocation(expression.type)
+            );
+        }
+
         return this.transformExpression(expression.expression);
     }
 

diff --git a/test/json.lua b/test/json.lua
@@ -112,11 +112,15 @@ end
 
 
 local function encode_number(val)
-  -- Check for NaN, -inf and inf
-  if val ~= val or val <= -math.huge or val >= math.huge then
-    error("unexpected number value '" .. tostring(val) .. "'")
+  if val ~= val then
+    return "NaN"
+  elseif val == math.huge then
+    return "Infinity"
+  elseif val == -math.huge then
+    return "-Infinity"
+  else
+    return string.format("%.17g", val)
   end
-  return string.format("%.14g", val)
 end
 
 
@@ -139,6 +143,7 @@ encode = function(val, stack)
 end
 
 
+-- TODO: Since it supports NaN and Infinity it is considered a superset of JSON, so it probably should be renamed
 function JSONStringify(val)
   return ( encode(val) )
 end
diff --git a/test/legacy-utils.ts b/test/legacy-utils.ts
@@ -0,0 +1,162 @@
+import { lauxlib, lua, lualib, to_jsstring, to_luastring } from "fengari";
+import * as fs from "fs";
+import * as path from "path";
+import * as ts from "typescript";
+import * as tstl from "../src";
+import * as tsHelper from "../src/TSHelper";
+
+export function transpileString(
+    str: string | { [filename: string]: string },
+    options: tstl.CompilerOptions = {},
+    ignoreDiagnostics = true
+): string {
+    const { diagnostics, file } = transpileStringResult(str, options);
+    expect(file.lua).toBeDefined();
+
+    const errors = diagnostics.filter(d => !ignoreDiagnostics || d.source === "typescript-to-lua");
+    expect(errors).not.toHaveDiagnostics();
+
+    return file.lua!.trim();
+}
+
+export function transpileStringsAsProject(
+    input: Record<string, string>,
+    options: tstl.CompilerOptions = {}
+): tstl.TranspileResult {
+    const optionsWithDefaults = {
+        luaTarget: tstl.LuaTarget.Lua53,
+        noHeader: true,
+        skipLibCheck: true,
+        target: ts.ScriptTarget.ESNext,
+        lib: ["lib.esnext.d.ts"],
+        experimentalDecorators: true,
+        ...options,
+    };
+
+    return tstl.transpileVirtualProject(input, optionsWithDefaults);
+}
+
+export function transpileStringResult(
+    input: string | Record<string, string>,
+    options: tstl.CompilerOptions = {}
+): Required<tstl.TranspileStringResult> {
+    const { diagnostics, transpiledFiles } = transpileStringsAsProject(
+        typeof input === "string" ? { "main.ts": input } : input,
+        options
+    );
+
+    const file = transpiledFiles.find(({ fileName }) => /\bmain\.[a-z]+$/.test(fileName));
+    if (file === undefined) {
+        throw new Error('Program should have a file named "main"');
+    }
+
+    return { diagnostics, file };
+}
+
+const lualibContent = fs.readFileSync(path.resolve(__dirname, "../dist/lualib/lualib_bundle.lua"), "utf8");
+const minimalTestLib = fs.readFileSync(path.join(__dirname, "json.lua"), "utf8") + "\n";
+export function executeLua(luaStr: string, withLib = true): any {
+    luaStr = luaStr.replace(/require\("lualib_bundle"\)/g, lualibContent);
+    if (withLib) {
+        luaStr = minimalTestLib + luaStr;
+    }
+
+    const L = lauxlib.luaL_newstate();
+    lualib.luaL_openlibs(L);
+    const status = lauxlib.luaL_dostring(L, to_luastring(luaStr));
+
+    if (status === lua.LUA_OK) {
+        // Read the return value from stack depending on its type.
+        if (lua.lua_isboolean(L, -1)) {
+            return lua.lua_toboolean(L, -1);
+        } else if (lua.lua_isnil(L, -1)) {
+            return undefined;
+        } else if (lua.lua_isnumber(L, -1)) {
+            return lua.lua_tonumber(L, -1);
+        } else if (lua.lua_isstring(L, -1)) {
+            return lua.lua_tojsstring(L, -1);
+        } else {
+            throw new Error("Unsupported lua return type: " + to_jsstring(lua.lua_typename(L, lua.lua_type(L, -1))));
+        }
+    } else {
+        // If the lua VM did not terminate with status code LUA_OK an error occurred.
+        // Throw a JS error with the message, retrieved by reading a string from the stack.
+
+        // Filter control characters out of string which are in there because ????
+        throw new Error("LUA ERROR: " + to_jsstring(lua.lua_tostring(L, -1).filter(c => c >= 20)));
+    }
+}
+
+export function transpileAndExecute(
+    tsStr: string,
+    compilerOptions?: tstl.CompilerOptions,
+    luaHeader?: string,
+    tsHeader?: string
+): any {
+    const wrappedTsString = `${tsHeader ? tsHeader : ""}
+        declare function JSONStringify(this: void, p: any): string;
+        function __runTest(this: void): any {${tsStr}}`;
+
+    const lua = `${luaHeader ? luaHeader : ""}
+        ${transpileString(wrappedTsString, compilerOptions, false)}
+        return __runTest();`;
+
+    return executeLua(lua);
+}
+
+export function transpileAndExecuteProjectReturningMainExport(
+    typeScriptFiles: Record<string, string>,
+    exportName: string,
+    options: tstl.CompilerOptions = {}
+): [any, string] {
+    const mainFile = Object.keys(typeScriptFiles).find(typeScriptFileName => typeScriptFileName === "main.ts");
+    if (!mainFile) {
+        throw new Error("An entry point file needs to be specified. This should be called main.ts");
+    }
+
+    const joinedTranspiledFiles = Object.keys(typeScriptFiles)
+        .filter(typeScriptFileName => typeScriptFileName !== "main.ts")
+        .map(typeScriptFileName => {
+            const modulePath = tsHelper.getExportPath(typeScriptFileName, options);
+            const tsCode = typeScriptFiles[typeScriptFileName];
+            const luaCode = transpileString(tsCode, options);
+            return `package.preload["${modulePath}"] = function()
+                ${luaCode}
+            end`;
+        })
+        .join("\n");
+
+    const luaCode = `return (function()
+        ${joinedTranspiledFiles}
+        ${transpileString(typeScriptFiles[mainFile])}
+    end)().${exportName}`;
+
+    try {
+        return [executeLua(luaCode), luaCode];
+    } catch (err) {
+        throw new Error(`
+            Encountered an error when executing the following Lua code:
+
+            ${luaCode}
+
+            ${err}
+        `);
+    }
+}
+
+export function transpileExecuteAndReturnExport(
+    tsStr: string,
+    returnExport: string,
+    compilerOptions?: tstl.CompilerOptions,
+    luaHeader?: string
+): any {
+    const wrappedTsString = `declare function JSONStringify(this: void, p: any): string;
+        ${tsStr}`;
+
+    const lua = `return (function()
+        ${luaHeader ? luaHeader : ""}
+        ${transpileString(wrappedTsString, compilerOptions, false)}
+        end)().${returnExport}`;
+
+    return executeLua(lua);
+}