typescript-to-lua 1.4.4 → 1.6.1

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/Map.lua

@@ -93,9 +93,8 @@ do
         return self:entries()
     end
     function Map.prototype.entries(self)
-        local ____temp_0 = self
-        local items = ____temp_0.items
-        local nextKey = ____temp_0.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)
@@ -123,9 +122,8 @@ do
         }
     end
     function Map.prototype.values(self)
-        local ____temp_1 = self
-        local items = ____temp_1.items
-        local nextKey = ____temp_1.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)

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)
@@ -1293,9 +1280,8 @@ do
         return self:entries()
     end
     function Map.prototype.entries(self)
-        local ____temp_0 = self
-        local items = ____temp_0.items
-        local nextKey = ____temp_0.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)
@@ -1323,9 +1309,8 @@ do
         }
     end
     function Map.prototype.values(self)
-        local ____temp_1 = self
-        local items = ____temp_1.items
-        local nextKey = ____temp_1.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)

package/dist/lualib-build/plugin.d.ts

@@ -7,7 +7,7 @@ export declare const lualibDiagnostic: ((message: string, file?: ts.SourceFile |
 };
 declare class LuaLibPlugin implements tstl.Plugin {
     visitors: {
-        303: (file: ts.SourceFile, context: tstl.TransformationContext) => tstl.File;
+        305: (file: ts.SourceFile, context: tstl.TransformationContext) => tstl.File;
     };
     printer: tstl.Printer;
     afterPrint(program: ts.Program, options: tstl.CompilerOptions, emitHost: EmitHost, result: ProcessedFile[]): ts.Diagnostic[];

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;