typescript-to-lua 1.4.4 → 1.5.0

package/dist/CompilerOptions.d.ts

@@ -23,6 +23,7 @@ export interface TypeScriptToLuaOptions {
     luaTarget?: LuaTarget;
     luaLibImport?: LuaLibImportKind;
     luaPlugins?: LuaPluginImport[];
+    noImplicitGlobalVariables?: boolean;
     noImplicitSelf?: boolean;
     noHeader?: boolean;
     noResolvePaths?: string[];

package/dist/cli/parse.js

@@ -39,6 +39,11 @@ exports.optionDeclarations = [
         type: "enum",
         choices: Object.values(CompilerOptions_1.LuaTarget),
     },
+    {
+        name: "noImplicitGlobalVariables",
+        description: 'Specify to prevent implicitly turning "normal" variants into global variables in the transpiled output.',
+        type: "boolean",
+    },
     {
         name: "noImplicitSelf",
         description: 'If "this" is implicitly considered an any type, do not generate a self parameter.',

package/dist/lualib/Await.lua

@@ -2,7 +2,7 @@ local function __TS__AsyncAwaiter(generator)
     return __TS__New(
         __TS__Promise,
         function(____, resolve, reject)
-            local adopt, fulfilled, rejected, step, asyncCoroutine
+            local adopt, fulfilled, step, resolved, asyncCoroutine
             function adopt(self, value)
                 local ____temp_0
                 if __TS__InstanceOf(value, __TS__Promise) then
@@ -13,55 +13,42 @@ local function __TS__AsyncAwaiter(generator)
                 return ____temp_0
             end
             function fulfilled(self, value)
-                local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine, value)
+                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
                 if success then
-                    step(nil, resultOrError, errorOrErrorHandler)
+                    step(nil, resultOrError)
                 else
-                    reject(nil, errorOrErrorHandler)
+                    reject(nil, resultOrError)
                 end
             end
-            function rejected(self, handler)
-                if handler then
-                    return function(____, value)
-                        local success, hasReturnedOrError, returnedValue = pcall(handler, value)
-                        if success then
-                            if hasReturnedOrError then
-                                resolve(nil, returnedValue)
-                            else
-                                step(nil, hasReturnedOrError, handler)
-                            end
-                        else
-                            reject(nil, hasReturnedOrError)
-                        end
-                    end
-                else
-                    return function(____, value)
-                        reject(nil, value)
-                    end
+            function step(self, result)
+                if resolved then
+                    return
                 end
-            end
-            function step(self, result, errorHandler)
                 if coroutine.status(asyncCoroutine) == "dead" then
                     resolve(nil, result)
                 else
                     local ____self_1 = adopt(nil, result)
-                    ____self_1["then"](
-                        ____self_1,
-                        fulfilled,
-                        rejected(nil, errorHandler)
-                    )
+                    ____self_1["then"](____self_1, fulfilled, reject)
                 end
             end
+            resolved = false
             asyncCoroutine = coroutine.create(generator)
-            local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine)
+            local success, resultOrError = coroutine.resume(
+                asyncCoroutine,
+                function(____, v)
+                    resolved = true
+                    local ____self_2 = adopt(nil, v)
+                    ____self_2["then"](____self_2, resolve, reject)
+                end
+            )
             if success then
-                step(nil, resultOrError, errorOrErrorHandler)
+                step(nil, resultOrError)
             else
-                reject(nil, errorOrErrorHandler)
+                reject(nil, resultOrError)
             end
         end
     )
 end
-local function __TS__Await(errorHandler, thing)
-    return coroutine.yield(errorHandler, thing)
+local function __TS__Await(thing)
+    return coroutine.yield(thing)
 end

package/dist/lualib/lualib_bundle.lua

@@ -753,7 +753,7 @@ local function __TS__AsyncAwaiter(generator)
     return __TS__New(
         __TS__Promise,
         function(____, resolve, reject)
-            local adopt, fulfilled, rejected, step, asyncCoroutine
+            local adopt, fulfilled, step, resolved, asyncCoroutine
             function adopt(self, value)
                 local ____temp_0
                 if __TS__InstanceOf(value, __TS__Promise) then
@@ -764,57 +764,44 @@ local function __TS__AsyncAwaiter(generator)
                 return ____temp_0
             end
             function fulfilled(self, value)
-                local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine, value)
+                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
                 if success then
-                    step(nil, resultOrError, errorOrErrorHandler)
+                    step(nil, resultOrError)
                 else
-                    reject(nil, errorOrErrorHandler)
+                    reject(nil, resultOrError)
                 end
             end
-            function rejected(self, handler)
-                if handler then
-                    return function(____, value)
-                        local success, hasReturnedOrError, returnedValue = pcall(handler, value)
-                        if success then
-                            if hasReturnedOrError then
-                                resolve(nil, returnedValue)
-                            else
-                                step(nil, hasReturnedOrError, handler)
-                            end
-                        else
-                            reject(nil, hasReturnedOrError)
-                        end
-                    end
-                else
-                    return function(____, value)
-                        reject(nil, value)
-                    end
+            function step(self, result)
+                if resolved then
+                    return
                 end
-            end
-            function step(self, result, errorHandler)
                 if coroutine.status(asyncCoroutine) == "dead" then
                     resolve(nil, result)
                 else
                     local ____self_1 = adopt(nil, result)
-                    ____self_1["then"](
-                        ____self_1,
-                        fulfilled,
-                        rejected(nil, errorHandler)
-                    )
+                    ____self_1["then"](____self_1, fulfilled, reject)
                 end
             end
+            resolved = false
             asyncCoroutine = coroutine.create(generator)
-            local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine)
+            local success, resultOrError = coroutine.resume(
+                asyncCoroutine,
+                function(____, v)
+                    resolved = true
+                    local ____self_2 = adopt(nil, v)
+                    ____self_2["then"](____self_2, resolve, reject)
+                end
+            )
             if success then
-                step(nil, resultOrError, errorOrErrorHandler)
+                step(nil, resultOrError)
             else
-                reject(nil, errorOrErrorHandler)
+                reject(nil, resultOrError)
             end
         end
     )
 end
-local function __TS__Await(errorHandler, thing)
-    return coroutine.yield(errorHandler, thing)
+local function __TS__Await(thing)
+    return coroutine.yield(thing)
 end
 
 local function __TS__ClassExtends(target, base)

package/dist/transformation/builtins/array.d.ts

@@ -1,7 +1,6 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformArrayConstructorCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformArrayPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformArrayConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function transformArrayPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
 export declare function transformArrayProperty(context: TransformationContext, node: ts.PropertyAccessExpression): lua.UnaryExpression | undefined;

package/dist/transformation/builtins/array.js

@@ -9,11 +9,10 @@ const call_1 = require("../visitors/call");
 const typescript_1 = require("../utils/typescript");
 const expression_list_1 = require("../visitors/expression-list");
 const lua_ast_1 = require("../utils/lua-ast");
-function transformArrayConstructorCall(context, node) {
-    const expression = node.expression;
+function transformArrayConstructorCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "from":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFrom, node, ...params);
@@ -22,7 +21,7 @@ function transformArrayConstructorCall(context, node) {
         case "of":
             return (0, lua_ast_1.wrapInTable)(...params);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Array", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Array", expressionName));
     }
 }
 exports.transformArrayConstructorCall = transformArrayConstructorCall;
@@ -45,11 +44,10 @@ function transformSingleElementArrayPush(context, node, caller, param) {
     context.addPrecedingStatements(pushStatement);
     return expressionIsUsed ? lengthExpression : lua.createNilLiteral();
 }
-function transformArrayPrototypeCall(context, node) {
-    const expression = node.expression;
+function transformArrayPrototypeCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, calledMethod.expression, node.arguments, signature);
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "concat":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayConcat, node, caller, ...params);
@@ -103,7 +101,7 @@ function transformArrayPrototypeCall(context, node) {
         case "splice":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySplice, node, caller, ...params);
         case "join":
-            const callerType = context.checker.getTypeAtLocation(expression.expression);
+            const callerType = context.checker.getTypeAtLocation(calledMethod.expression);
             const elementType = context.checker.getElementTypeOfArrayType(callerType);
             if (elementType && ((0, typescript_1.isStringType)(context, elementType) || (0, typescript_1.isNumberType)(context, elementType))) {
                 const defaultSeparatorLiteral = lua.createStringLiteral(",");
@@ -124,7 +122,7 @@ function transformArrayPrototypeCall(context, node) {
         case "flatMap":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlatMap, node, caller, ...params);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "array", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "array", expressionName));
     }
 }
 exports.transformArrayPrototypeCall = transformArrayPrototypeCall;

package/dist/transformation/builtins/console.d.ts

@@ -1,4 +1,4 @@
+import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformConsoleCall(context: TransformationContext, expression: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformConsoleCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/console.js

@@ -6,17 +6,16 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const call_1 = require("../visitors/call");
 const isStringFormatTemplate = (node) => ts.isStringLiteral(node) && node.text.includes("%");
-function transformConsoleCall(context, expression) {
-    const method = expression.expression;
-    const methodName = method.name.text;
-    const signature = context.checker.getResolvedSignature(expression);
-    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
+function transformConsoleCall(context, node, calledMethod) {
+    const methodName = calledMethod.name.text;
+    const signature = context.checker.getResolvedSignature(node);
+    const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
     switch (methodName) {
         case "error":
         case "info":
         case "log":
         case "warn":
-            if (expression.arguments.length > 0 && isStringFormatTemplate(expression.arguments[0])) {
+            if (node.arguments.length > 0 && isStringFormatTemplate(node.arguments[0])) {
                 // print(string.format([arguments]))
                 const stringFormatCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("format")), parameters);
                 return lua.createCallExpression(lua.createIdentifier("print"), [stringFormatCall]);
@@ -24,7 +23,7 @@ function transformConsoleCall(context, expression) {
             // print([arguments])
             return lua.createCallExpression(lua.createIdentifier("print"), parameters);
         case "assert":
-            if (expression.arguments.length > 1 && isStringFormatTemplate(expression.arguments[1])) {
+            if (node.arguments.length > 1 && isStringFormatTemplate(node.arguments[1])) {
                 // assert([condition], string.format([arguments]))
                 const stringFormatCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("format")), parameters.slice(1));
                 return lua.createCallExpression(lua.createIdentifier("assert"), [parameters[0], stringFormatCall]);
@@ -32,7 +31,7 @@ function transformConsoleCall(context, expression) {
             // assert()
             return lua.createCallExpression(lua.createIdentifier("assert"), parameters);
         case "trace":
-            if (expression.arguments.length > 0 && isStringFormatTemplate(expression.arguments[0])) {
+            if (node.arguments.length > 0 && isStringFormatTemplate(node.arguments[0])) {
                 // print(debug.traceback(string.format([arguments])))
                 const stringFormatCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("format")), parameters);
                 const debugTracebackCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("debug"), lua.createStringLiteral("traceback")), [stringFormatCall]);
@@ -42,7 +41,7 @@ function transformConsoleCall(context, expression) {
             const debugTracebackCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("debug"), lua.createStringLiteral("traceback")), parameters);
             return lua.createCallExpression(lua.createIdentifier("print"), [debugTracebackCall]);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "console", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "console", methodName));
     }
 }
 exports.transformConsoleCall = transformConsoleCall;

package/dist/transformation/builtins/function.d.ts

@@ -1,6 +1,5 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformFunctionPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.CallExpression | undefined;
+export declare function transformFunctionPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.CallExpression | undefined;
 export declare function transformFunctionProperty(context: TransformationContext, node: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/function.js

@@ -8,15 +8,14 @@ const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
-function transformFunctionPrototypeCall(context, node) {
-    const expression = node.expression;
-    const callerType = context.checker.getTypeAtLocation(expression.expression);
+function transformFunctionPrototypeCall(context, node, calledMethod) {
+    const callerType = context.checker.getTypeAtLocation(calledMethod.expression);
     if ((0, function_context_1.getFunctionContextType)(context, callerType) === function_context_1.ContextType.Void) {
         context.diagnostics.push((0, diagnostics_1.unsupportedSelfFunctionConversion)(node));
     }
     const signature = context.checker.getResolvedSignature(node);
-    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, calledMethod.expression, node.arguments, signature);
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "apply":
             const nonContextArgs = params.length > 1 ? [(0, lua_ast_1.createUnpackCall)(context, params[1], node.arguments[1])] : [];
@@ -26,7 +25,7 @@ function transformFunctionPrototypeCall(context, node) {
         case "call":
             return lua.createCallExpression(caller, params, node);
         case "toString":
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "function", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "function", expressionName));
     }
 }
 exports.transformFunctionPrototypeCall = transformFunctionPrototypeCall;

package/dist/transformation/builtins/index.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkForLuaLibType = exports.transformBuiltinIdentifierExpression = exports.transformBuiltinCallExpression = exports.transformBuiltinPropertyAccessExpression = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
-const utils_1 = require("../../utils");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
 const symbols_1 = require("../utils/symbols");
 const typescript_1 = require("../utils/typescript");
+const call_1 = require("../visitors/call");
 const array_1 = require("./array");
 const console_1 = require("./console");
 const function_1 = require("./function");
@@ -55,80 +55,79 @@ function transformBuiltinCallExpression(context, node, isOptionalCall) {
             return result;
         }
     }
-    const expression = ts.getOriginalNode(node.expression);
-    if (!ts.isPropertyAccessExpression(expression)) {
+    const calledMethod = ts.getOriginalNode((0, call_1.getCalledExpression)(node));
+    if (!ts.isPropertyAccessExpression(calledMethod)) {
         return;
     }
-    const isOptionalAccess = expression.questionDotToken;
-    (0, utils_1.assume)(node);
+    const isOptionalAccess = calledMethod.questionDotToken;
     // If the function being called is of type owner.func, get the type of owner
-    const ownerType = context.checker.getTypeAtLocation(expression.expression);
+    const ownerType = context.checker.getTypeAtLocation(calledMethod.expression);
     if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
         const symbol = ownerType.getSymbol();
         switch (symbol === null || symbol === void 0 ? void 0 : symbol.name) {
             case "ArrayConstructor":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, array_1.transformArrayConstructorCall)(context, node);
+                return (0, array_1.transformArrayConstructorCall)(context, node, calledMethod);
             case "Console":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, console_1.transformConsoleCall)(context, node);
+                return (0, console_1.transformConsoleCall)(context, node, calledMethod);
             case "Math":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, math_1.transformMathCall)(context, node);
+                return (0, math_1.transformMathCall)(context, node, calledMethod);
             case "StringConstructor":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, string_1.transformStringConstructorCall)(context, node);
+                return (0, string_1.transformStringConstructorCall)(context, node, calledMethod);
             case "ObjectConstructor":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, object_1.transformObjectConstructorCall)(context, node);
+                return (0, object_1.transformObjectConstructorCall)(context, node, calledMethod);
             case "SymbolConstructor":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, symbol_1.transformSymbolConstructorCall)(context, node);
+                return (0, symbol_1.transformSymbolConstructorCall)(context, node, calledMethod);
             case "NumberConstructor":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, number_1.transformNumberConstructorCall)(context, node);
+                return (0, number_1.transformNumberConstructorCall)(context, node, calledMethod);
             case "PromiseConstructor":
                 if (isOptionalCall || isOptionalAccess)
                     return unsupportedOptionalCall();
-                return (0, promise_1.transformPromiseConstructorCall)(context, node);
+                return (0, promise_1.transformPromiseConstructorCall)(context, node, calledMethod);
         }
     }
     const isStringFunction = (0, typescript_1.isStringType)(context, ownerType) ||
-        (expression.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isStringType));
+        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isStringType));
     if (isStringFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
         if (isOptionalCall)
             return unsupportedOptionalCall();
-        return (0, string_1.transformStringPrototypeCall)(context, node);
+        return (0, string_1.transformStringPrototypeCall)(context, node, calledMethod);
     }
     const isNumberFunction = (0, typescript_1.isNumberType)(context, ownerType) ||
-        (expression.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isNumberType));
+        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isNumberType));
     if (isNumberFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
         if (isOptionalCall)
             return unsupportedOptionalCall();
-        return (0, number_1.transformNumberPrototypeCall)(context, node);
+        return (0, number_1.transformNumberPrototypeCall)(context, node, calledMethod);
     }
     const isArrayFunction = (0, typescript_1.isArrayType)(context, ownerType) ||
-        (expression.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isArrayType));
+        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isArrayType));
     if (isArrayFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
         if (isOptionalCall)
             return unsupportedOptionalCall();
-        return (0, array_1.transformArrayPrototypeCall)(context, node);
+        return (0, array_1.transformArrayPrototypeCall)(context, node, calledMethod);
     }
     const isFunctionFunction = (0, typescript_1.isFunctionType)(ownerType) ||
-        (expression.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, (_, t) => (0, typescript_1.isFunctionType)(t)));
+        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, (_, t) => (0, typescript_1.isFunctionType)(t)));
     if (isFunctionFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
         if (isOptionalCall)
             return unsupportedOptionalCall();
-        return (0, function_1.transformFunctionPrototypeCall)(context, node);
+        return (0, function_1.transformFunctionPrototypeCall)(context, node, calledMethod);
     }
-    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, expression);
+    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, calledMethod);
     if (objectResult) {
         if (isOptionalCall)
             return unsupportedOptionalCall();

package/dist/transformation/builtins/math.d.ts

@@ -1,6 +1,5 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
 export declare function transformMathProperty(context: TransformationContext, node: ts.PropertyAccessExpression): lua.Expression | undefined;
-export declare function transformMathCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformMathCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/math.js

@@ -26,12 +26,11 @@ function transformMathProperty(context, node) {
     }
 }
 exports.transformMathProperty = transformMathProperty;
-function transformMathCall(context, node) {
-    const expression = node.expression;
+function transformMathCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const math = lua.createIdentifier("math");
-    const expressionName = expression.name.text;
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         // Lua 5.3: math.atan(y, x)
         // Otherwise: math.atan2(y, x)
@@ -90,7 +89,7 @@ function transformMathCall(context, node) {
             return lua.createCallExpression(lua.createTableIndexExpression(math, method), params, node);
         }
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Math", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Math", expressionName));
     }
 }
 exports.transformMathCall = transformMathCall;

package/dist/transformation/builtins/number.d.ts

@@ -1,5 +1,5 @@
+import ts = require("typescript");
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformNumberPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformNumberConstructorCall(context: TransformationContext, expression: PropertyCallExpression): lua.CallExpression | undefined;
+export declare function transformNumberPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function transformNumberConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.CallExpression | undefined;

package/dist/transformation/builtins/number.js

@@ -5,33 +5,31 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
-function transformNumberPrototypeCall(context, node) {
-    const expression = node.expression;
+function transformNumberPrototypeCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
-    const expressionName = expression.name.text;
+    const caller = context.transformExpression(calledMethod.expression);
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "toString":
             return params.length === 0
                 ? lua.createCallExpression(lua.createIdentifier("tostring"), [caller], node)
                 : (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberToString, node, caller, ...params);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "number", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "number", expressionName));
     }
 }
 exports.transformNumberPrototypeCall = transformNumberPrototypeCall;
-function transformNumberConstructorCall(context, expression) {
-    const method = expression.expression;
-    const parameters = (0, call_1.transformArguments)(context, expression.arguments);
-    const methodName = method.name.text;
+function transformNumberConstructorCall(context, node, calledMethod) {
+    const parameters = (0, call_1.transformArguments)(context, node.arguments);
+    const methodName = calledMethod.name.text;
     switch (methodName) {
         case "isNaN":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberIsNaN, expression, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberIsNaN, node, ...parameters);
         case "isFinite":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberIsFinite, expression, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberIsFinite, node, ...parameters);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Number", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Number", methodName));
     }
 }
 exports.transformNumberConstructorCall = transformNumberConstructorCall;

package/dist/transformation/builtins/object.d.ts

@@ -1,6 +1,5 @@
 import * as lua from "../../LuaAST";
 import * as ts from "typescript";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformObjectConstructorCall(context: TransformationContext, expression: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, expression: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function transformObjectConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function transformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/object.js

@@ -5,41 +5,40 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
-function transformObjectConstructorCall(context, expression) {
-    const method = expression.expression;
-    const args = (0, call_1.transformArguments)(context, expression.arguments);
-    const methodName = method.name.text;
+function transformObjectConstructorCall(context, node, calledMethod) {
+    const args = (0, call_1.transformArguments)(context, node.arguments);
+    const methodName = calledMethod.name.text;
     switch (methodName) {
         case "assign":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, node, ...args);
         case "defineProperty":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectDefineProperty, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectDefineProperty, node, ...args);
         case "entries":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectEntries, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectEntries, node, ...args);
         case "fromEntries":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectFromEntries, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectFromEntries, node, ...args);
         case "getOwnPropertyDescriptor":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptor, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptor, node, ...args);
         case "getOwnPropertyDescriptors":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptors, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptors, node, ...args);
         case "keys":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectKeys, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectKeys, node, ...args);
         case "values":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectValues, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectValues, node, ...args);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Object", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Object", methodName));
     }
 }
 exports.transformObjectConstructorCall = transformObjectConstructorCall;
-function transformObjectPrototypeCall(context, node, expression) {
+function transformObjectPrototypeCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    const name = expression.name.text;
+    const name = calledMethod.name.text;
     switch (name) {
         case "toString":
             const toStringIdentifier = lua.createIdentifier("tostring");
-            return lua.createCallExpression(toStringIdentifier, [context.transformExpression(expression.expression)], node);
+            return lua.createCallExpression(toStringIdentifier, [context.transformExpression(calledMethod.expression)], node);
         case "hasOwnProperty":
-            const expr = context.transformExpression(expression.expression);
+            const expr = context.transformExpression(calledMethod.expression);
             const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
             const rawGetIdentifier = lua.createIdentifier("rawget");
             const rawGetCall = lua.createCallExpression(rawGetIdentifier, [expr, ...parameters]);

package/dist/transformation/builtins/promise.d.ts

@@ -1,8 +1,7 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
 export declare function isPromiseClass(context: TransformationContext, node: ts.Identifier): boolean;
 export declare function createPromiseIdentifier(original: ts.Node): lua.Identifier;
-export declare function transformPromiseConstructorCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformPromiseConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
 export declare function createStaticPromiseFunctionAccessor(functionName: string, node: ts.Node): lua.TableIndexExpression;

package/dist/transformation/builtins/promise.js

@@ -15,11 +15,10 @@ function createPromiseIdentifier(original) {
     return lua.createIdentifier("__TS__Promise", original);
 }
 exports.createPromiseIdentifier = createPromiseIdentifier;
-function transformPromiseConstructorCall(context, node) {
-    const expression = node.expression;
+function transformPromiseConstructorCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "all":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAll, node, ...params);
@@ -31,12 +30,12 @@ function transformPromiseConstructorCall(context, node) {
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseRace, node, ...params);
         case "resolve":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-            return lua.createCallExpression(createStaticPromiseFunctionAccessor("resolve", expression), params, node);
+            return lua.createCallExpression(createStaticPromiseFunctionAccessor("resolve", calledMethod), params, node);
         case "reject":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
-            return lua.createCallExpression(createStaticPromiseFunctionAccessor("reject", expression), params, node);
+            return lua.createCallExpression(createStaticPromiseFunctionAccessor("reject", calledMethod), params, node);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Promise", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Promise", expressionName));
     }
 }
 exports.transformPromiseConstructorCall = transformPromiseConstructorCall;

package/dist/transformation/builtins/string.d.ts

@@ -1,7 +1,6 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformStringPrototypeCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
-export declare function transformStringConstructorCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformStringPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function transformStringConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
 export declare function transformStringProperty(context: TransformationContext, node: ts.PropertyAccessExpression): lua.UnaryExpression | undefined;

package/dist/transformation/builtins/string.js

@@ -10,11 +10,10 @@ function createStringCall(methodName, tsOriginal, ...params) {
     const stringIdentifier = lua.createIdentifier("string");
     return lua.createCallExpression(lua.createTableIndexExpression(stringIdentifier, lua.createStringLiteral(methodName)), params, tsOriginal);
 }
-function transformStringPrototypeCall(context, node) {
-    const expression = node.expression;
+function transformStringPrototypeCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, calledMethod.expression, node.arguments, signature);
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "replace":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
@@ -102,20 +101,19 @@ function transformStringPrototypeCall(context, node) {
         case "padEnd":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "string", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "string", expressionName));
     }
 }
 exports.transformStringPrototypeCall = transformStringPrototypeCall;
-function transformStringConstructorCall(context, node) {
-    const expression = node.expression;
+function transformStringConstructorCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     const params = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const expressionName = expression.name.text;
+    const expressionName = calledMethod.name.text;
     switch (expressionName) {
         case "fromCharCode":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("char")), params, node);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "String", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "String", expressionName));
     }
 }
 exports.transformStringConstructorCall = transformStringConstructorCall;

package/dist/transformation/builtins/symbol.d.ts

@@ -1,4 +1,4 @@
+import ts = require("typescript");
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { PropertyCallExpression } from "../visitors/call";
-export declare function transformSymbolConstructorCall(context: TransformationContext, expression: PropertyCallExpression): lua.CallExpression | undefined;
+export declare function transformSymbolConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.CallExpression | undefined;

package/dist/transformation/builtins/symbol.js

@@ -5,20 +5,19 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
-function transformSymbolConstructorCall(context, expression) {
-    const method = expression.expression;
-    const signature = context.checker.getResolvedSignature(expression);
-    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
-    const methodName = method.name.text;
+function transformSymbolConstructorCall(context, node, calledMethod) {
+    const signature = context.checker.getResolvedSignature(node);
+    const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
+    const methodName = calledMethod.name.text;
     switch (methodName) {
         case "for":
         case "keyFor":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.SymbolRegistry);
             const upperMethodName = methodName[0].toUpperCase() + methodName.slice(1);
             const functionIdentifier = lua.createIdentifier(`__TS__SymbolRegistry${upperMethodName}`);
-            return lua.createCallExpression(functionIdentifier, parameters, expression);
+            return lua.createCallExpression(functionIdentifier, parameters, node);
         default:
-            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Symbol", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "Symbol", methodName));
     }
 }
 exports.transformSymbolConstructorCall = transformSymbolConstructorCall;

package/dist/transformation/utils/lua-ast.js

@@ -104,6 +104,7 @@ function hasMultipleReferences(scope, identifiers) {
 function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal, overrideExportScope) {
     let declaration;
     let assignment;
+    const noImplicitGlobalVariables = context.options.noImplicitGlobalVariables === true;
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
     const identifiers = (0, utils_1.castArray)(lhs);
     if (identifiers.length === 0) {
@@ -122,7 +123,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     else {
         const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
-        if (context.isModule || !isTopLevelVariable) {
+        if (context.isModule || !isTopLevelVariable || noImplicitGlobalVariables) {
             const isLuaFunctionExpression = rhs && !Array.isArray(rhs) && lua.isFunctionExpression(rhs);
             const isSafeRecursiveFunctionDeclaration = isFunctionDeclaration && isLuaFunctionExpression;
             if (!isSafeRecursiveFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
@@ -163,6 +164,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
             }
         }
     }
+    setJSDocComments(context, tsOriginal, declaration, assignment);
     if (declaration && assignment) {
         return [declaration, assignment];
     }
@@ -177,6 +179,86 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     }
 }
 exports.createLocalOrExportedOrGlobalDeclaration = createLocalOrExportedOrGlobalDeclaration;
+/**
+ * Apply JSDoc comments to the newly-created Lua statement, if present.
+ * https://stackoverflow.com/questions/47429792/is-it-possible-to-get-comments-as-nodes-in-the-ast-using-the-typescript-compiler
+ */
+function setJSDocComments(context, tsOriginal, declaration, assignment) {
+    // Respect the vanilla TypeScript option of "removeComments":
+    // https://www.typescriptlang.org/tsconfig#removeComments
+    if (context.options.removeComments) {
+        return;
+    }
+    const docCommentArray = getJSDocCommentFromTSNode(context, tsOriginal);
+    if (docCommentArray === undefined) {
+        return;
+    }
+    if (declaration && assignment) {
+        declaration.leadingComments = docCommentArray;
+    }
+    else if (declaration) {
+        declaration.leadingComments = docCommentArray;
+    }
+    else if (assignment) {
+        assignment.leadingComments = docCommentArray;
+    }
+}
+function getJSDocCommentFromTSNode(context, tsOriginal) {
+    if (tsOriginal === undefined) {
+        return undefined;
+    }
+    // The "name" property is only on a subset of node types; we want to be permissive and get the
+    // comments from as many nodes as possible.
+    const node = tsOriginal;
+    if (node.name === undefined) {
+        return undefined;
+    }
+    const symbol = context.checker.getSymbolAtLocation(node.name);
+    if (symbol === undefined) {
+        return undefined;
+    }
+    // The TypeScript compiler separates JSDoc comments into the "documentation comment" and the
+    // "tags". The former is conventionally at the top of the comment, and the bottom is
+    // conventionally at the bottom. We need to get both from the TypeScript API and then combine
+    // them into one block of text.
+    const docCommentArray = symbol.getDocumentationComment(context.checker);
+    const docCommentText = ts.displayPartsToString(docCommentArray).trim();
+    const jsDocTagInfoArray = symbol.getJsDocTags(context.checker);
+    const jsDocTagsTextLines = jsDocTagInfoArray.map(jsDocTagInfo => {
+        let text = "@" + jsDocTagInfo.name;
+        if (jsDocTagInfo.text !== undefined) {
+            const tagDescriptionTextArray = jsDocTagInfo.text
+                .filter(symbolDisplayPart => symbolDisplayPart.text.trim() !== "")
+                .map(symbolDisplayPart => symbolDisplayPart.text.trim());
+            const tagDescriptionText = tagDescriptionTextArray.join(" ");
+            text += " " + tagDescriptionText;
+        }
+        return text;
+    });
+    const jsDocTagsText = jsDocTagsTextLines.join("\n");
+    const combined = (docCommentText + "\n\n" + jsDocTagsText).trim();
+    if (combined === "") {
+        return undefined;
+    }
+    // By default, TSTL will display comments immediately next to the "--" characters. We can make
+    // the comments look better if we separate them by a space (similar to what Prettier does in
+    // JavaScript/TypeScript).
+    const linesWithoutSpace = combined.split("\n");
+    const lines = linesWithoutSpace.map(line => ` ${line}`);
+    // We want to JSDoc comments to map on to LDoc comments:
+    // https://stevedonovan.github.io/ldoc/manual/doc.md.html
+    // LDoc comments require that the first line starts with three hyphens.
+    // Thus, need to add a hyphen to the first line.
+    const firstLine = lines[0];
+    if (firstLine.startsWith(" @")) {
+        lines.unshift("-");
+    }
+    else {
+        lines.shift();
+        lines.unshift("-" + firstLine);
+    }
+    return lines;
+}
 const createNaN = (tsOriginal) => lua.createBinaryExpression(lua.createNumericLiteral(0), lua.createNumericLiteral(0), lua.SyntaxKind.DivisionOperator, tsOriginal);
 exports.createNaN = createNaN;
 //# sourceMappingURL=lua-ast.js.map

package/dist/transformation/visitors/async-await.d.ts

@@ -3,4 +3,4 @@ import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare const transformAwaitExpression: FunctionVisitor<ts.AwaitExpression>;
 export declare function isAsyncFunction(declaration: ts.FunctionLikeDeclaration): boolean;
-export declare function wrapInAsyncAwaiter(context: TransformationContext, statements: lua.Statement[]): lua.Statement[];
+export declare function wrapInAsyncAwaiter(context: TransformationContext, statements: lua.Statement[], includeResolveParameter?: boolean): lua.CallExpression;

package/dist/transformation/visitors/async-await.js

@@ -7,16 +7,12 @@ const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 const typescript_1 = require("../utils/typescript");
 const transformAwaitExpression = (node, context) => {
-    var _a;
     // Check if await is inside an async function, it is not allowed at top level or in non-async functions
-    const containingFunction = (0, typescript_1.findFirstNodeAbove)(node, ts.isFunctionLike);
-    if (containingFunction === undefined ||
-        !((_a = containingFunction.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword))) {
+    if (!(0, typescript_1.isInAsyncFunction)(node)) {
         context.diagnostics.push((0, diagnostics_1.awaitMustBeInAsyncFunction)(node));
     }
     const expression = context.transformExpression(node.expression);
-    const catchIdentifier = lua.createIdentifier("____catch");
-    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Await, node, catchIdentifier, expression);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Await, node, expression);
 };
 exports.transformAwaitExpression = transformAwaitExpression;
 function isAsyncFunction(declaration) {
@@ -24,15 +20,12 @@ function isAsyncFunction(declaration) {
     return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
 }
 exports.isAsyncFunction = isAsyncFunction;
-function wrapInAsyncAwaiter(context, statements) {
+function wrapInAsyncAwaiter(context, statements, includeResolveParameter = true) {
     (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Await);
-    return [
-        lua.createReturnStatement([
-            lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [
-                lua.createFunctionExpression(lua.createBlock(statements)),
-            ]),
-        ]),
-    ];
+    const parameters = includeResolveParameter ? [lua.createIdentifier("____awaiter_resolve")] : [];
+    return lua.createCallExpression(lua.createIdentifier("__TS__AsyncAwaiter"), [
+        lua.createFunctionExpression(lua.createBlock(statements), parameters),
+    ]);
 }
 exports.wrapInAsyncAwaiter = wrapInAsyncAwaiter;
 //# sourceMappingURL=async-await.js.map

package/dist/transformation/visitors/call.d.ts

@@ -1,11 +1,9 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
-export declare type PropertyCallExpression = ts.CallExpression & {
-    expression: ts.PropertyAccessExpression;
-};
 export declare function validateArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature): void;
 export declare function transformArguments(context: TransformationContext, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): lua.Expression[];
 export declare function transformCallAndArguments(context: TransformationContext, callExpression: ts.Expression, params: readonly ts.Expression[], signature?: ts.Signature, callContext?: ts.Expression): [lua.Expression, lua.Expression[]];
 export declare function transformContextualCallExpression(context: TransformationContext, node: ts.CallExpression | ts.TaggedTemplateExpression, args: ts.Expression[] | ts.NodeArray<ts.Expression>, signature?: ts.Signature): lua.Expression;
 export declare const transformCallExpression: FunctionVisitor<ts.CallExpression>;
+export declare function getCalledExpression(node: ts.CallExpression): ts.Expression;

package/dist/transformation/visitors/call.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
+exports.getCalledExpression = exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -82,7 +82,7 @@ function transformContextualCallExpression(context, node, args, signature) {
     if (ts.isOptionalChain(node)) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
-    const left = ts.isCallExpression(node) ? node.expression : node.tag;
+    const left = ts.isCallExpression(node) ? getCalledExpression(node) : node.tag;
     let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
     if (ts.isPropertyAccessExpression(left) &&
         ts.isIdentifier(left.name) &&
@@ -113,9 +113,9 @@ function transformContextualCallExpression(context, node, args, signature) {
     }
 }
 exports.transformContextualCallExpression = transformContextualCallExpression;
-function transformPropertyCall(context, node) {
+function transformPropertyCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
-    if (node.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
+    if (calledMethod.expression.kind === ts.SyntaxKind.SuperKeyword) {
         // Super calls take the format of super.call(self,...)
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(context.transformExpression(node.expression), parameters);
@@ -146,14 +146,15 @@ function transformElementCall(context, node) {
 }
 const transformCallExpression = (node, context) => {
     var _a;
-    if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+    const calledExpression = getCalledExpression(node);
+    if (calledExpression.kind === ts.SyntaxKind.ImportKeyword) {
         return (0, import_1.transformImportExpression)(node, context);
     }
     if (ts.isOptionalChain(node)) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
-    const optionalContinuation = ts.isIdentifier(node.expression)
-        ? (0, optional_chaining_1.getOptionalContinuationData)(node.expression)
+    const optionalContinuation = ts.isIdentifier(calledExpression)
+        ? (0, optional_chaining_1.getOptionalContinuationData)(calledExpression)
         : undefined;
     const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
     if ((0, annotations_1.isTupleReturnCall)(context, node)) {
@@ -164,22 +165,22 @@ const transformCallExpression = (node, context) => {
         // unsupportedOptionalCall diagnostic already present
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
-    if (ts.isPropertyAccessExpression(node.expression)) {
-        const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
+    if (ts.isPropertyAccessExpression(calledExpression)) {
+        const ownerType = context.checker.getTypeAtLocation(calledExpression.expression);
         const annotations = (0, annotations_1.getTypeAnnotations)(ownerType);
         if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
             context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
         }
-        const result = transformPropertyCall(context, node);
+        const result = transformPropertyCall(context, node, calledExpression);
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
-    if (ts.isElementAccessExpression(node.expression)) {
+    if (ts.isElementAccessExpression(calledExpression)) {
         const result = transformElementCall(context, node);
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     const signature = context.checker.getResolvedSignature(node);
     // Handle super calls properly
-    if (node.expression.kind === ts.SyntaxKind.SuperKeyword) {
+    if (calledExpression.kind === ts.SyntaxKind.SuperKeyword) {
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters);
     }
@@ -188,13 +189,13 @@ const transformCallExpression = (node, context) => {
     let parameters;
     const isContextualCall = !signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
     if (!isContextualCall) {
-        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature);
+        [callPath, parameters] = transformCallAndArguments(context, calledExpression, node.arguments, signature);
     }
     else {
         // if is optionalContinuation, context will be handled by transformOptionalChain.
         const useGlobalContext = !context.isStrict && optionalContinuation === undefined;
         const callContext = useGlobalContext ? ts.factory.createIdentifier("_G") : ts.factory.createNull();
-        [callPath, parameters] = transformCallAndArguments(context, node.expression, node.arguments, signature, callContext);
+        [callPath, parameters] = transformCallAndArguments(context, calledExpression, node.arguments, signature, callContext);
     }
     const callExpression = lua.createCallExpression(callPath, parameters, node);
     if (optionalContinuation && isContextualCall) {
@@ -203,4 +204,12 @@ const transformCallExpression = (node, context) => {
     return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(callExpression) : callExpression;
 };
 exports.transformCallExpression = transformCallExpression;
+function getCalledExpression(node) {
+    function unwrapExpression(expression) {
+        expression = ts.skipOuterExpressions(expression);
+        return ts.isNonNullExpression(expression) ? unwrapExpression(expression.expression) : expression;
+    }
+    return unwrapExpression(node.expression);
+}
+exports.getCalledExpression = getCalledExpression;
 //# sourceMappingURL=call.js.map

package/dist/transformation/visitors/errors.js

@@ -5,21 +5,58 @@ const __1 = require("../..");
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lua_ast_1 = require("../utils/lua-ast");
+const lualib_1 = require("../utils/lualib");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
+const async_await_1 = require("./async-await");
 const block_1 = require("./block");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const return_1 = require("./return");
-const transformTryStatement = (statement, context) => {
-    var _a;
-    const [tryBlock, tryScope] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
-    if (context.options.luaTarget === __1.LuaTarget.Lua51 &&
-        (0, typescript_1.isInAsyncFunction)(statement) &&
-        !context.options.lua51AllowTryCatchInAsyncAwait) {
+const transformAsyncTry = (statement, context) => {
+    const [tryBlock] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
+    if (context.options.luaTarget === __1.LuaTarget.Lua51 && !context.options.lua51AllowTryCatchInAsyncAwait) {
         context.diagnostics.push((0, diagnostics_1.unsupportedForTargetButOverrideAvailable)(statement, "try/catch inside async functions", __1.LuaTarget.Lua51, "lua51AllowTryCatchInAsyncAwait"));
         return tryBlock.statements;
     }
+    // __TS__AsyncAwaiter(<catch block>)
+    const awaiter = (0, async_await_1.wrapInAsyncAwaiter)(context, tryBlock.statements, false);
+    const awaiterIdentifier = lua.createIdentifier("____try");
+    const awaiterDefinition = lua.createVariableDeclarationStatement(awaiterIdentifier, awaiter);
+    // local ____try = __TS__AsyncAwaiter(<catch block>)
+    const result = [awaiterDefinition];
+    if (statement.finallyBlock) {
+        const awaiterFinally = lua.createTableIndexExpression(awaiterIdentifier, lua.createStringLiteral("finally"));
+        const finallyFunction = lua.createFunctionExpression(lua.createBlock(context.transformStatements(statement.finallyBlock.statements)));
+        const finallyCall = lua.createCallExpression(awaiterFinally, [awaiterIdentifier, finallyFunction], statement.finallyBlock);
+        // ____try.finally(<finally function>)
+        result.push(lua.createExpressionStatement(finallyCall));
+    }
+    if (statement.catchClause) {
+        // ____try.catch(<catch function>)
+        const [catchFunction] = transformCatchClause(context, statement.catchClause);
+        if (catchFunction.params) {
+            catchFunction.params.unshift(lua.createAnonymousIdentifier());
+        }
+        const awaiterCatch = lua.createTableIndexExpression(awaiterIdentifier, lua.createStringLiteral("catch"));
+        const catchCall = lua.createCallExpression(awaiterCatch, [awaiterIdentifier, catchFunction]);
+        // await ____try.catch(<catch function>)
+        const promiseAwait = (0, lualib_1.transformLuaLibFunction)(context, __1.LuaLibFeature.Await, statement, catchCall);
+        result.push(lua.createExpressionStatement(promiseAwait, statement));
+    }
+    else {
+        // await ____try
+        const promiseAwait = (0, lualib_1.transformLuaLibFunction)(context, __1.LuaLibFeature.Await, statement, awaiterIdentifier);
+        result.push(lua.createExpressionStatement(promiseAwait, statement));
+    }
+    return result;
+};
+const transformTryStatement = (statement, context) => {
+    var _a;
+    if ((0, typescript_1.isInAsyncFunction)(statement)) {
+        return transformAsyncTry(statement, context);
+    }
+    const [tryBlock, tryScope] = (0, block_1.transformScopeBlock)(context, statement.tryBlock, scope_1.ScopeType.Try);
     if (context.options.luaTarget === __1.LuaTarget.Lua51 && (0, typescript_1.isInGeneratorFunction)(statement)) {
         context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "try/catch inside generator functions", __1.LuaTarget.Lua51));
         return tryBlock.statements;
@@ -33,11 +70,7 @@ const transformTryStatement = (statement, context) => {
     const tryCall = lua.createCallExpression(pCall, [lua.createFunctionExpression(tryBlock)]);
     if (statement.catchClause && statement.catchClause.block.statements.length > 0) {
         // try with catch
-        const [catchBlock, catchScope] = (0, block_1.transformScopeBlock)(context, statement.catchClause.block, scope_1.ScopeType.Catch);
-        const catchParameter = statement.catchClause.variableDeclaration
-            ? (0, identifier_1.transformIdentifier)(context, statement.catchClause.variableDeclaration.name)
-            : undefined;
-        const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+        const [catchFunction, catchScope] = transformCatchClause(context, statement.catchClause);
         const catchIdentifier = lua.createIdentifier("____catch");
         result.push(lua.createVariableDeclarationStatement(catchIdentifier, catchFunction));
         const hasReturn = (_a = tryScope.functionReturned) !== null && _a !== void 0 ? _a : catchScope.functionReturned;
@@ -96,4 +129,12 @@ const transformThrowStatement = (statement, context) => {
     return lua.createExpressionStatement(lua.createCallExpression(lua.createIdentifier("error"), parameters), statement);
 };
 exports.transformThrowStatement = transformThrowStatement;
+function transformCatchClause(context, catchClause) {
+    const [catchBlock, catchScope] = (0, block_1.transformScopeBlock)(context, catchClause.block, scope_1.ScopeType.Catch);
+    const catchParameter = catchClause.variableDeclaration
+        ? (0, identifier_1.transformIdentifier)(context, catchClause.variableDeclaration.name)
+        : undefined;
+    const catchFunction = lua.createFunctionExpression(catchBlock, catchParameter ? [lua.cloneIdentifier(catchParameter)] : []);
+    return [catchFunction, catchScope];
+}
 //# sourceMappingURL=errors.js.map

package/dist/transformation/visitors/function.js

@@ -114,7 +114,7 @@ function transformFunctionBody(context, parameters, body, spreadIdentifier, node
     scope.node = node;
     let bodyStatements = transformFunctionBodyContent(context, body);
     if (node && (0, async_await_1.isAsyncFunction)(node)) {
-        bodyStatements = (0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements);
+        bodyStatements = [lua.createReturnStatement([(0, async_await_1.wrapInAsyncAwaiter)(context, bodyStatements)])];
     }
     const headerStatements = transformFunctionBodyHeader(context, scope, parameters, spreadIdentifier);
     (0, scope_1.popScope)(context);

package/dist/transformation/visitors/return.js

@@ -61,14 +61,15 @@ const transformReturnStatement = (statement, context) => {
 exports.transformReturnStatement = transformReturnStatement;
 function createReturnStatement(context, values, node) {
     const results = [...values];
+    if ((0, typescript_1.isInAsyncFunction)(node)) {
+        return lua.createReturnStatement([
+            lua.createCallExpression(lua.createIdentifier("____awaiter_resolve"), [lua.createNilLiteral(), ...values]),
+        ]);
+    }
     if (isInTryCatch(context)) {
         // Bubble up explicit return flag and check if we're inside a try/catch block
         results.unshift(lua.createBooleanLiteral(true));
     }
-    else if ((0, typescript_1.isInAsyncFunction)(node)) {
-        // Add nil error handler in async function and not in try
-        results.unshift(lua.createNilLiteral());
-    }
     return lua.createReturnStatement(results, node);
 }
 exports.createReturnStatement = createReturnStatement;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.4.4",
+    "version": "1.5.0",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",