typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/builtins/array.js

@@ -9,69 +9,68 @@ const typescript_1 = require("../utils/typescript");
 function transformArrayConstructorCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "isArray":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayIsArray, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayIsArray, node, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "Array", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Array", expressionName));
     }
 }
 exports.transformArrayConstructorCall = transformArrayConstructorCall;
 function transformArrayPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "concat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayConcat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayConcat, node, caller, ...params);
         case "entries":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayEntries, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayEntries, node, caller);
         case "push":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayPush, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayPush, node, caller, ...params);
         case "reverse":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayReverse, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReverse, node, caller);
         case "shift":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayShift, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayShift, node, caller);
         case "unshift":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayUnshift, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayUnshift, node, caller, ...params);
         case "sort":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySort, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySort, node, caller, ...params);
         case "pop":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("remove")), [caller], node);
         case "forEach":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayForEach, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayForEach, node, caller, ...params);
         case "find":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFind, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFind, node, caller, ...params);
         case "findIndex":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFindIndex, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFindIndex, node, caller, ...params);
         case "includes":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayIncludes, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayIncludes, node, caller, ...params);
         case "indexOf":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayIndexOf, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayIndexOf, node, caller, ...params);
         case "map":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayMap, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayMap, node, caller, ...params);
         case "filter":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFilter, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFilter, node, caller, ...params);
         case "reduce":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayReduce, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReduce, node, caller, ...params);
         case "reduceRight":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayReduceRight, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReduceRight, node, caller, ...params);
         case "some":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySome, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySome, node, caller, ...params);
         case "every":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayEvery, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayEvery, node, caller, ...params);
         case "slice":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySlice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, node, caller, ...params);
         case "splice":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySplice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySplice, node, caller, ...params);
         case "join":
             const callerType = context.checker.getTypeAtLocation(expression.expression);
             const elementType = context.checker.getElementTypeOfArrayType(callerType);
-            if (elementType && (typescript_1.isStringType(context, elementType) || typescript_1.isNumberType(context, elementType))) {
+            if (elementType && ((0, typescript_1.isStringType)(context, elementType) || (0, typescript_1.isNumberType)(context, elementType))) {
                 const defaultSeparatorLiteral = lua.createStringLiteral(",");
                 const parameters = [
                     caller,
@@ -81,13 +80,13 @@ function transformArrayPrototypeCall(context, node) {
                 ];
                 return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("concat")), parameters, node);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayJoin, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayJoin, node, caller, ...params);
         case "flat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFlat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlat, node, caller, ...params);
         case "flatMap":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFlatMap, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlatMap, node, caller, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "array", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "array", expressionName));
     }
 }
 exports.transformArrayPrototypeCall = transformArrayPrototypeCall;

package/dist/transformation/builtins/console.js

@@ -10,7 +10,7 @@ function transformConsoleCall(context, expression) {
     const method = expression.expression;
     const methodName = method.name.text;
     const signature = context.checker.getResolvedSignature(expression);
-    const parameters = call_1.transformArguments(context, expression.arguments, signature);
+    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
     switch (methodName) {
         case "error":
         case "info":
@@ -42,7 +42,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(diagnostics_1.unsupportedProperty(method.name, "console", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "console", methodName));
     }
 }
 exports.transformConsoleCall = transformConsoleCall;

package/dist/transformation/builtins/function.js

@@ -11,22 +11,21 @@ const call_1 = require("../visitors/call");
 function transformFunctionPrototypeCall(context, node) {
     const expression = node.expression;
     const callerType = context.checker.getTypeAtLocation(expression.expression);
-    if (function_context_1.getFunctionContextType(context, callerType) === function_context_1.ContextType.Void) {
-        context.diagnostics.push(diagnostics_1.unsupportedSelfFunctionConversion(node));
+    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 params = call_1.transformArguments(context, node.arguments, signature);
-    const caller = context.transformExpression(expression.expression);
+    const [caller, params] = (0, call_1.transformCallAndArguments)(context, expression.expression, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "apply":
-            return lua.createCallExpression(caller, [params[0], lua_ast_1.createUnpackCall(context, params[1], node.arguments[1])], node);
+            return lua.createCallExpression(caller, [params[0], (0, lua_ast_1.createUnpackCall)(context, params[1], node.arguments[1])], node);
         case "bind":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.FunctionBind, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.FunctionBind, node, caller, ...params);
         case "call":
             return lua.createCallExpression(caller, params, node);
-        default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "function", expressionName));
+        case "toString":
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "function", expressionName));
     }
 }
 exports.transformFunctionPrototypeCall = transformFunctionPrototypeCall;
@@ -34,17 +33,20 @@ function transformFunctionProperty(context, node) {
     switch (node.name.text) {
         case "length":
             if (context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-                context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "function.length", CompilerOptions_1.LuaTarget.Lua51));
+                context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "function.length", CompilerOptions_1.LuaTarget.Lua51));
             }
             // debug.getinfo(fn)
             const getInfoCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("debug"), lua.createStringLiteral("getinfo")), [context.transformExpression(node.expression)]);
             const nparams = lua.createTableIndexExpression(getInfoCall, lua.createStringLiteral("nparams"));
-            const contextType = function_context_1.getFunctionContextType(context, context.checker.getTypeAtLocation(node.expression));
+            const contextType = (0, function_context_1.getFunctionContextType)(context, context.checker.getTypeAtLocation(node.expression));
             return contextType === function_context_1.ContextType.NonVoid
                 ? lua.createBinaryExpression(nparams, lua.createNumericLiteral(1), lua.SyntaxKind.SubtractionOperator)
                 : nparams;
-        default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "function", node.name.text));
+        case "arguments":
+        case "caller":
+        case "displayName":
+        case "name":
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "function", node.name.text));
     }
 }
 exports.transformFunctionProperty = transformFunctionProperty;

package/dist/transformation/builtins/global.js

@@ -6,24 +6,24 @@ const typescript_1 = require("../utils/typescript");
 const call_1 = require("../visitors/call");
 function transformGlobalCall(context, node) {
     const signature = context.checker.getResolvedSignature(node);
-    const parameters = call_1.transformArguments(context, node.arguments, signature);
+    const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     const name = expressionType.symbol.name;
     switch (name) {
         case "SymbolConstructor":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Symbol, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Symbol, node, ...parameters);
         case "NumberConstructor":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Number, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, node, ...parameters);
         case "isNaN":
         case "isFinite":
-            const numberParameters = typescript_1.isNumberType(context, expressionType)
+            const numberParameters = (0, typescript_1.isNumberType)(context, expressionType)
                 ? parameters
-                : [lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Number, undefined, ...parameters)];
-            return lualib_1.transformLuaLibFunction(context, name === "isNaN" ? lualib_1.LuaLibFeature.NumberIsNaN : lualib_1.LuaLibFeature.NumberIsFinite, node, ...numberParameters);
+                : [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, undefined, ...parameters)];
+            return (0, lualib_1.transformLuaLibFunction)(context, name === "isNaN" ? lualib_1.LuaLibFeature.NumberIsNaN : lualib_1.LuaLibFeature.NumberIsFinite, node, ...numberParameters);
         case "parseFloat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ParseFloat, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseFloat, node, ...parameters);
         case "parseInt":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ParseInt, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseInt, node, ...parameters);
     }
 }
 exports.transformGlobalCall = transformGlobalCall;

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

@@ -2,5 +2,5 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function transformBuiltinPropertyAccessExpression(context: TransformationContext, node: ts.PropertyAccessExpression): lua.Expression | undefined;
-export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;
+export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression, isOptionalCall: boolean): lua.Expression | undefined;
 export declare function transformBuiltinIdentifierExpression(context: TransformationContext, node: ts.Identifier): lua.Expression | undefined;

package/dist/transformation/builtins/index.js

@@ -19,78 +19,111 @@ const object_1 = require("./object");
 const promise_1 = require("./promise");
 const string_1 = require("./string");
 const symbol_1 = require("./symbol");
+const diagnostics_1 = require("../utils/diagnostics");
 function transformBuiltinPropertyAccessExpression(context, node) {
     const ownerType = context.checker.getTypeAtLocation(node.expression);
-    if (typescript_1.isStringType(context, ownerType)) {
-        return string_1.transformStringProperty(context, node);
+    if ((0, typescript_1.isStringType)(context, ownerType)) {
+        return (0, string_1.transformStringProperty)(context, node);
     }
-    if (typescript_1.isArrayType(context, ownerType)) {
-        return array_1.transformArrayProperty(context, node);
+    if ((0, typescript_1.isArrayType)(context, ownerType)) {
+        return (0, array_1.transformArrayProperty)(context, node);
     }
-    if (typescript_1.isFunctionType(context, ownerType)) {
-        return function_1.transformFunctionProperty(context, node);
+    if ((0, typescript_1.isFunctionType)(ownerType)) {
+        return (0, function_1.transformFunctionProperty)(context, node);
     }
-    if (ts.isIdentifier(node.expression) && typescript_1.isStandardLibraryType(context, ownerType, undefined)) {
+    if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
         switch (node.expression.text) {
             case "Math":
-                return math_1.transformMathProperty(context, node);
+                return (0, math_1.transformMathProperty)(context, node);
             case "Symbol":
-                lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Symbol);
+                (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Symbol);
         }
     }
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
-function transformBuiltinCallExpression(context, node) {
+function transformBuiltinCallExpression(context, node, isOptionalCall) {
     const expressionType = context.checker.getTypeAtLocation(node.expression);
-    if (ts.isIdentifier(node.expression) && typescript_1.isStandardLibraryType(context, expressionType, undefined)) {
+    if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         // TODO:
-        new_1.checkForLuaLibType(context, expressionType);
-        const result = global_1.transformGlobalCall(context, node);
+        (0, new_1.checkForLuaLibType)(context, expressionType);
+        const result = (0, global_1.transformGlobalCall)(context, node);
         if (result) {
             return result;
         }
     }
-    if (!ts.isPropertyAccessExpression(node.expression)) {
+    const expression = ts.getOriginalNode(node.expression);
+    if (!ts.isPropertyAccessExpression(expression)) {
         return;
     }
-    utils_1.assume(node);
+    (0, utils_1.assume)(node);
+    const isOptionalAccess = expression.questionDotToken;
+    const unsupportedOptionalCall = () => {
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        return lua.createNilLiteral();
+    };
     // If the function being called is of type owner.func, get the type of owner
-    const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
-    if (typescript_1.isStandardLibraryType(context, ownerType, undefined)) {
+    const ownerType = context.checker.getTypeAtLocation(expression.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":
-                return array_1.transformArrayConstructorCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, array_1.transformArrayConstructorCall)(context, node);
             case "Console":
-                return console_1.transformConsoleCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, console_1.transformConsoleCall)(context, node);
             case "Math":
-                return math_1.transformMathCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, math_1.transformMathCall)(context, node);
             case "StringConstructor":
-                return string_1.transformStringConstructorCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, string_1.transformStringConstructorCall)(context, node);
             case "ObjectConstructor":
-                return object_1.transformObjectConstructorCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, object_1.transformObjectConstructorCall)(context, node);
             case "SymbolConstructor":
-                return symbol_1.transformSymbolConstructorCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, symbol_1.transformSymbolConstructorCall)(context, node);
             case "NumberConstructor":
-                return number_1.transformNumberConstructorCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, number_1.transformNumberConstructorCall)(context, node);
             case "PromiseConstructor":
-                return promise_1.transformPromiseConstructorCall(context, node);
+                if (isOptionalCall || isOptionalAccess)
+                    return unsupportedOptionalCall();
+                return (0, promise_1.transformPromiseConstructorCall)(context, node);
         }
     }
-    if (typescript_1.isStringType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return string_1.transformStringPrototypeCall(context, node);
+    if ((0, typescript_1.isStringType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
+        return (0, string_1.transformStringPrototypeCall)(context, node);
     }
-    if (typescript_1.isNumberType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return number_1.transformNumberPrototypeCall(context, node);
+    if ((0, typescript_1.isNumberType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
+        return (0, number_1.transformNumberPrototypeCall)(context, node);
     }
-    if (typescript_1.isArrayType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return array_1.transformArrayPrototypeCall(context, node);
+    if ((0, typescript_1.isArrayType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
+        return (0, array_1.transformArrayPrototypeCall)(context, node);
     }
-    if (typescript_1.isFunctionType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return function_1.transformFunctionPrototypeCall(context, node);
+    if ((0, typescript_1.isFunctionType)(ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
+        return (0, function_1.transformFunctionPrototypeCall)(context, node);
     }
-    const objectResult = object_1.transformObjectPrototypeCall(context, node);
+    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, expression);
     if (objectResult) {
+        if (isOptionalCall)
+            return unsupportedOptionalCall();
         return objectResult;
     }
 }
@@ -98,13 +131,13 @@ exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
 function transformBuiltinIdentifierExpression(context, node) {
     switch (node.text) {
         case "NaN":
-            return lua_ast_1.createNaN(node);
+            return (0, lua_ast_1.createNaN)(node);
         case "Infinity":
             const math = lua.createIdentifier("math");
             const huge = lua.createStringLiteral("huge");
             return lua.createTableIndexExpression(math, huge, node);
         case "globalThis":
-            return lua.createIdentifier("_G", node, symbols_1.getIdentifierSymbolId(context, node), "globalThis");
+            return lua.createIdentifier("_G", node, (0, symbols_1.getIdentifierSymbolId)(context, node), "globalThis");
     }
 }
 exports.transformBuiltinIdentifierExpression = transformBuiltinIdentifierExpression;

package/dist/transformation/builtins/math.js

@@ -22,14 +22,14 @@ function transformMathProperty(context, node) {
         case "SQRT2":
             return lua.createNumericLiteral(Math[name], node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "Math", name));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "Math", name));
     }
 }
 exports.transformMathProperty = transformMathProperty;
 function transformMathCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const math = lua.createIdentifier("math");
     const expressionName = expression.name.text;
     switch (expressionName) {
@@ -37,7 +37,7 @@ function transformMathCall(context, node) {
         // Otherwise: math.atan2(y, x)
         case "atan2": {
             if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-                return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.MathAtan2, node, ...params);
+                return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.MathAtan2, node, ...params);
             }
             const method = lua.createStringLiteral(context.luaTarget === CompilerOptions_1.LuaTarget.Lua53 ? "atan" : "atan2");
             return lua.createCallExpression(lua.createTableIndexExpression(math, method), params, node);
@@ -84,7 +84,7 @@ function transformMathCall(context, node) {
             return lua.createCallExpression(lua.createTableIndexExpression(math, method), params, node);
         }
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "Math", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Math", expressionName));
     }
 }
 exports.transformMathCall = transformMathCall;

package/dist/transformation/builtins/number.js

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

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

@@ -1,5 +1,6 @@
 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: PropertyCallExpression): lua.Expression | undefined;
+export declare function transformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, expression: ts.PropertyAccessExpression): lua.Expression | undefined;

package/dist/transformation/builtins/object.js

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

package/dist/transformation/builtins/promise.js

@@ -8,7 +8,7 @@ const typescript_1 = require("../utils/typescript");
 const call_1 = require("../visitors/call");
 function isPromiseClass(context, node) {
     const type = context.checker.getTypeAtLocation(node);
-    return typescript_1.isStandardLibraryType(context, type, undefined) && node.text === "Promise";
+    return (0, typescript_1.isStandardLibraryType)(context, type, undefined) && node.text === "Promise";
 }
 exports.isPromiseClass = isPromiseClass;
 function createPromiseIdentifier(original) {
@@ -18,25 +18,25 @@ exports.createPromiseIdentifier = createPromiseIdentifier;
 function transformPromiseConstructorCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "all":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseAll, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAll, node, ...params);
         case "allSettled":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseAllSettled, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAllSettled, node, ...params);
         case "any":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseAny, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAny, node, ...params);
         case "race":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseRace, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseRace, node, ...params);
         case "resolve":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Promise);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
             return lua.createCallExpression(createStaticPromiseFunctionAccessor("resolve", expression), params, node);
         case "reject":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Promise);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
             return lua.createCallExpression(createStaticPromiseFunctionAccessor("reject", expression), params, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "Promise", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Promise", expressionName));
     }
 }
 exports.transformPromiseConstructorCall = transformPromiseConstructorCall;