typescript-to-lua 1.4.2 → 1.5.0

package/dist/lualib/lualib_module_info.json

@@ -45,7 +45,6 @@
       "__TS__ArrayFrom"
     ],
     "dependencies": [
-      "ArrayPush",
       "Iterator"
     ]
   },
@@ -79,6 +78,11 @@
       "__TS__ArrayPush"
     ]
   },
+  "ArrayPushArray": {
+    "exports": [
+      "__TS__ArrayPushArray"
+    ]
+  },
   "ArrayReduce": {
     "exports": [
       "__TS__ArrayReduce"
@@ -94,11 +98,6 @@
       "__TS__ArrayReverse"
     ]
   },
-  "ArrayShift": {
-    "exports": [
-      "__TS__ArrayShift"
-    ]
-  },
   "ArrayUnshift": {
     "exports": [
       "__TS__ArrayUnshift"
@@ -135,7 +134,7 @@
     ],
     "dependencies": [
       "ArrayIsArray",
-      "ArrayConcat"
+      "ArrayFlat"
     ]
   },
   "ArrayFlatMap": {
@@ -143,8 +142,7 @@
       "__TS__ArrayFlatMap"
     ],
     "dependencies": [
-      "ArrayIsArray",
-      "ArrayConcat"
+      "ArrayIsArray"
     ]
   },
   "ArraySetLength": {
@@ -233,7 +231,8 @@
       "__TS__FunctionBind"
     ],
     "dependencies": [
-      "Unpack"
+      "Unpack",
+      "ArrayUnshift"
     ]
   },
   "Generator": {
@@ -390,8 +389,7 @@
       "New",
       "InstanceOf",
       "Class",
-      "FunctionBind",
-      "ArrayPush"
+      "FunctionBind"
     ]
   },
   "PromiseAll": {
@@ -423,7 +421,6 @@
     "dependencies": [
       "InstanceOf",
       "Promise",
-      "ArrayPush",
       "Iterator",
       "New"
     ]
@@ -435,7 +432,6 @@
     "dependencies": [
       "InstanceOf",
       "Promise",
-      "ArrayPush",
       "Iterator",
       "New"
     ]
@@ -521,11 +517,6 @@
       "__TS__StringCharCodeAt"
     ]
   },
-  "StringConcat": {
-    "exports": [
-      "__TS__StringConcat"
-    ]
-  },
   "StringEndsWith": {
     "exports": [
       "__TS__StringEndsWith"
@@ -554,6 +545,9 @@
   "StringReplaceAll": {
     "exports": [
       "__TS__StringReplaceAll"
+    ],
+    "dependencies": [
+      "StringSplit"
     ]
   },
   "StringSlice": {
@@ -564,10 +558,6 @@
   "StringSplit": {
     "exports": [
       "__TS__StringSplit"
-    ],
-    "dependencies": [
-      "StringAccess",
-      "StringSubstring"
     ]
   },
   "StringStartsWith": {

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.CallExpression | 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

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformArrayProperty = exports.transformArrayPrototypeCall = exports.transformArrayConstructorCall = void 0;
+const ts = require("typescript");
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
 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);
@@ -20,26 +21,53 @@ 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;
-function transformArrayPrototypeCall(context, node) {
-    const expression = node.expression;
+/**
+ * Optimized single element Array.push
+ *
+ * array[#array+1] = el
+ * return (#array + 1)
+ */
+function transformSingleElementArrayPush(context, node, caller, param) {
+    const expressionIsUsed = !ts.isExpressionStatement((0, typescript_1.findFirstNonOuterParent)(node));
+    const arrayIdentifier = lua.isIdentifier(caller) ? caller : (0, expression_list_1.moveToPrecedingTemp)(context, caller);
+    // #array + 1
+    let lengthExpression = lua.createBinaryExpression(lua.createUnaryExpression(arrayIdentifier, lua.SyntaxKind.LengthOperator), lua.createNumericLiteral(1), lua.SyntaxKind.AdditionOperator);
+    if (expressionIsUsed) {
+        // store length in a temp
+        lengthExpression = (0, expression_list_1.moveToPrecedingTemp)(context, lengthExpression);
+    }
+    const pushStatement = lua.createAssignmentStatement(lua.createTableIndexExpression(arrayIdentifier, lengthExpression), param, node);
+    context.addPrecedingStatements(pushStatement);
+    return expressionIsUsed ? lengthExpression : lua.createNilLiteral();
+}
+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);
         case "entries":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayEntries, node, caller);
         case "push":
+            if (node.arguments.length === 1) {
+                const param = params[0];
+                if ((0, lua_ast_1.isUnpackCall)(param)) {
+                    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayPushArray, node, caller, param.params[0]);
+                }
+                if (!lua.isDotsLiteral(param)) {
+                    return transformSingleElementArrayPush(context, node, caller, param);
+                }
+            }
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayPush, node, caller, ...params);
         case "reverse":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReverse, node, caller);
         case "shift":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayShift, node, caller);
+            return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("remove")), [caller, lua.createNumericLiteral(1)], node);
         case "unshift":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayUnshift, node, caller, ...params);
         case "sort":
@@ -73,15 +101,18 @@ 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(",");
+                const param = params[0];
                 const parameters = [
                     caller,
                     node.arguments.length === 0
                         ? defaultSeparatorLiteral
-                        : lua.createBinaryExpression(params[0], defaultSeparatorLiteral, lua.SyntaxKind.OrOperator),
+                        : lua.isStringLiteral(param)
+                            ? param
+                            : lua.createBinaryExpression(param, defaultSeparatorLiteral, lua.SyntaxKind.OrOperator),
                 ];
                 return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("concat")), parameters, node);
             }
@@ -91,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,7 +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;