typescript-to-lua 1.6.3 → 1.7.0

package/dist/CompilerOptions.d.ts

@@ -31,6 +31,7 @@ export interface TypeScriptToLuaOptions {
     sourceMapTraceback?: boolean;
     tstlVerbose?: boolean;
     lua51AllowTryCatchInAsyncAwait?: boolean;
+    measurePerformance?: boolean;
 }
 export declare type CompilerOptions = OmitIndexSignature<ts.CompilerOptions> & TypeScriptToLuaOptions & {
     [option: string]: any;

package/dist/cli/parse.js

@@ -79,6 +79,11 @@ exports.optionDeclarations = [
         description: "Always allow try/catch in async/await functions for Lua 5.1.",
         type: "boolean",
     },
+    {
+        name: "measurePerformance",
+        description: "Measure performance of the tstl compiler.",
+        type: "boolean",
+    },
 ];
 function updateParsedConfigFile(parsedConfigFile) {
     let hasRootLevelOptions = false;

package/dist/lualib/ArraySlice.lua

@@ -1,6 +1,10 @@
 local function __TS__ArraySlice(self, first, last)
     local len = #self
-    first = first or 0
+    local ____first_0 = first
+    if ____first_0 == nil then
+        ____first_0 = 0
+    end
+    first = ____first_0
     if first < 0 then
         first = len + first
         if first < 0 then
@@ -11,7 +15,11 @@ local function __TS__ArraySlice(self, first, last)
             first = len
         end
     end
-    last = last or len
+    local ____last_1 = last
+    if ____last_1 == nil then
+        ____last_1 = len
+    end
+    last = ____last_1
     if last < 0 then
         last = len + last
         if last < 0 then

package/dist/lualib/ArraySplice.lua

@@ -22,7 +22,11 @@ local function __TS__ArraySplice(self, ...)
     elseif actualArgumentCount == 1 then
         actualDeleteCount = len - start
     else
-        actualDeleteCount = deleteCount or 0
+        local ____deleteCount_0 = deleteCount
+        if ____deleteCount_0 == nil then
+            ____deleteCount_0 = 0
+        end
+        actualDeleteCount = ____deleteCount_0
         if actualDeleteCount < 0 then
             actualDeleteCount = 0
         end

package/dist/lualib/Generator.lua

@@ -22,7 +22,14 @@ do
             local args = {...}
             local argsLength = select("#", ...)
             return {
-                ____coroutine = coroutine.create(function() return fn((unpack or table.unpack)(args, 1, argsLength)) end),
+                ____coroutine = coroutine.create(function()
+                    local ____fn_1 = fn
+                    local ____unpack_0 = unpack
+                    if ____unpack_0 == nil then
+                        ____unpack_0 = table.unpack
+                    end
+                    return ____fn_1(____unpack_0(args, 1, argsLength))
+                end),
                 [Symbol.iterator] = generatorIterator,
                 next = generatorNext
             }

package/dist/lualib/ParseFloat.lua

@@ -10,5 +10,9 @@ local function __TS__ParseFloat(numberString)
         return ____temp_0
     end
     local number = tonumber(string.match(numberString, "^%s*(-?%d+%.?%d*)"))
-    return number or 0 / 0
+    local ____number_1 = number
+    if ____number_1 == nil then
+        ____number_1 = 0 / 0
+    end
+    return ____number_1
 end

package/dist/lualib/SparseArraySpread.lua

@@ -1,4 +1,8 @@
 local function __TS__SparseArraySpread(sparseArray)
-    local _unpack = unpack or table.unpack
+    local ____unpack_0 = unpack
+    if ____unpack_0 == nil then
+        ____unpack_0 = table.unpack
+    end
+    local _unpack = ____unpack_0
     return _unpack(sparseArray, 1, sparseArray.sparseLength)
 end

package/dist/lualib/StringCharCodeAt.lua

@@ -5,5 +5,9 @@ local function __TS__StringCharCodeAt(self, index)
     if index < 0 then
         return 0 / 0
     end
-    return string.byte(self, index + 1) or 0 / 0
+    local ____string_byte_result_0 = string.byte(self, index + 1)
+    if ____string_byte_result_0 == nil then
+        ____string_byte_result_0 = 0 / 0
+    end
+    return ____string_byte_result_0
 end

package/dist/lualib/lualib_bundle.lua

@@ -345,7 +345,11 @@ end
 
 local function __TS__ArraySlice(self, first, last)
     local len = #self
-    first = first or 0
+    local ____first_0 = first
+    if ____first_0 == nil then
+        ____first_0 = 0
+    end
+    first = ____first_0
     if first < 0 then
         first = len + first
         if first < 0 then
@@ -356,7 +360,11 @@ local function __TS__ArraySlice(self, first, last)
             first = len
         end
     end
-    last = last or len
+    local ____last_1 = last
+    if ____last_1 == nil then
+        ____last_1 = len
+    end
+    last = ____last_1
     if last < 0 then
         last = len + last
         if last < 0 then
@@ -412,7 +420,11 @@ local function __TS__ArraySplice(self, ...)
     elseif actualArgumentCount == 1 then
         actualDeleteCount = len - start
     else
-        actualDeleteCount = deleteCount or 0
+        local ____deleteCount_0 = deleteCount
+        if ____deleteCount_0 == nil then
+            ____deleteCount_0 = 0
+        end
+        actualDeleteCount = ____deleteCount_0
         if actualDeleteCount < 0 then
             actualDeleteCount = 0
         end
@@ -1175,7 +1187,14 @@ do
             local args = {...}
             local argsLength = select("#", ...)
             return {
-                ____coroutine = coroutine.create(function() return fn((unpack or table.unpack)(args, 1, argsLength)) end),
+                ____coroutine = coroutine.create(function()
+                    local ____fn_1 = fn
+                    local ____unpack_0 = unpack
+                    if ____unpack_0 == nil then
+                        ____unpack_0 = table.unpack
+                    end
+                    return ____fn_1(____unpack_0(args, 1, argsLength))
+                end),
                 [Symbol.iterator] = generatorIterator,
                 next = generatorNext
             }
@@ -1553,7 +1572,11 @@ local function __TS__ParseFloat(numberString)
         return ____temp_0
     end
     local number = tonumber(string.match(numberString, "^%s*(-?%d+%.?%d*)"))
-    return number or 0 / 0
+    local ____number_1 = number
+    if ____number_1 == nil then
+        ____number_1 = 0 / 0
+    end
+    return ____number_1
 end
 
 local function __TS__StringSubstr(self, from, length)
@@ -1947,7 +1970,11 @@ local function __TS__SparseArrayPush(sparseArray, ...)
 end
 
 local function __TS__SparseArraySpread(sparseArray)
-    local _unpack = unpack or table.unpack
+    local ____unpack_0 = unpack
+    if ____unpack_0 == nil then
+        ____unpack_0 = table.unpack
+    end
+    local _unpack = ____unpack_0
     return _unpack(sparseArray, 1, sparseArray.sparseLength)
 end
 
@@ -2127,7 +2154,11 @@ local function __TS__StringCharCodeAt(self, index)
     if index < 0 then
         return 0 / 0
     end
-    return string.byte(self, index + 1) or 0 / 0
+    local ____string_byte_result_0 = string.byte(self, index + 1)
+    if ____string_byte_result_0 == nil then
+        ____string_byte_result_0 = 0 / 0
+    end
+    return ____string_byte_result_0
 end
 
 local function __TS__StringEndsWith(self, searchString, endPosition)

package/dist/lualib-build/plugin.js

@@ -4,7 +4,6 @@ exports.lualibDiagnostic = void 0;
 const ts = require("typescript");
 const tstl = require("..");
 const path = require("path");
-const lualib_1 = require("../transformation/utils/lualib");
 const LuaLib_1 = require("../LuaLib");
 const util_1 = require("./util");
 const utils_1 = require("../utils");
@@ -51,7 +50,7 @@ class LuaLibPlugin {
         }
         // Transpile file as normal with tstl
         const fileResult = context.superTransformNode(file)[0];
-        const usedFeatures = new Set((0, lualib_1.getUsedLuaLibFeatures)(context));
+        const usedFeatures = new Set(context.usedLuaLibFeatures);
         // Get all imports in file
         const importNames = new Set();
         const imports = file.statements.filter(ts.isImportDeclaration);

package/dist/measure-performance.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Starts a performance measurement section.
+ * @param name name of the measurement
+ */
+export declare function startSection(name: string): void;
+/**
+ * Ends a performance measurement section.
+ * @param name name of the measurement
+ */
+export declare function endSection(name: string): void;
+export declare function isMeasurementEnabled(): boolean;
+export declare function enableMeasurement(): void;
+export declare function disableMeasurement(): void;
+export declare function forEachMeasure(callback: (measureName: string, duration: number) => void): void;
+export declare function getTotalDuration(): number;

package/dist/measure-performance.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalDuration = exports.forEachMeasure = exports.disableMeasurement = exports.enableMeasurement = exports.isMeasurementEnabled = exports.endSection = exports.startSection = void 0;
+const perf_hooks_1 = require("perf_hooks");
+// We use our own performance hooks implementation for easier use, but also call node's performance hooks, so it shows up in the profiler.
+let enabled = false;
+const marks = new Map();
+const durations = new Map();
+function timestamp() {
+    return perf_hooks_1.performance.now();
+}
+/**
+ * Marks a performance event, with the given markName.
+ */
+function mark(markName) {
+    if (enabled) {
+        marks.set(markName, timestamp());
+        perf_hooks_1.performance.mark(markName);
+    }
+}
+/**
+ * Adds a performance measurement with the specified name.
+ *
+ * @param measureName The name of the performance measurement.
+ * @param startMarkName The name of the starting mark
+ * @param endMarkName The name of the ending mark
+ */
+function measure(measureName, startMarkName, endMarkName) {
+    var _a, _b, _c;
+    if (enabled) {
+        const end = (_a = marks.get(endMarkName)) !== null && _a !== void 0 ? _a : timestamp();
+        const start = (_b = marks.get(startMarkName)) !== null && _b !== void 0 ? _b : perf_hooks_1.performance.timeOrigin;
+        const previousDuration = (_c = durations.get(measureName)) !== null && _c !== void 0 ? _c : 0;
+        durations.set(measureName, previousDuration + (end - start));
+        perf_hooks_1.performance.measure(measureName, startMarkName, endMarkName);
+    }
+}
+/**
+ * Starts a performance measurement section.
+ * @param name name of the measurement
+ */
+function startSection(name) {
+    mark("start " + name);
+}
+exports.startSection = startSection;
+/**
+ * Ends a performance measurement section.
+ * @param name name of the measurement
+ */
+function endSection(name) {
+    mark("end " + name);
+    measure(name, "start " + name, "end " + name);
+}
+exports.endSection = endSection;
+function isMeasurementEnabled() {
+    return enabled;
+}
+exports.isMeasurementEnabled = isMeasurementEnabled;
+function enableMeasurement() {
+    if (!enabled) {
+        enabled = true;
+    }
+}
+exports.enableMeasurement = enableMeasurement;
+function disableMeasurement() {
+    if (enabled) {
+        enabled = false;
+        marks.clear();
+        durations.clear();
+    }
+}
+exports.disableMeasurement = disableMeasurement;
+function forEachMeasure(callback) {
+    durations.forEach((duration, measureName) => callback(measureName, duration));
+}
+exports.forEachMeasure = forEachMeasure;
+function getTotalDuration() {
+    let total = 0;
+    forEachMeasure((_, duration) => (total += duration));
+    return total;
+}
+exports.getTotalDuration = getTotalDuration;
+//# sourceMappingURL=measure-performance.js.map

package/dist/transformation/builtins/array.js

@@ -103,7 +103,8 @@ function transformArrayPrototypeCall(context, node, calledMethod) {
         case "join":
             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))) {
+            if (elementType &&
+                (0, typescript_1.typeAlwaysHasSomeOfFlags)(context, elementType, ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike)) {
                 const defaultSeparatorLiteral = lua.createStringLiteral(",");
                 const param = params[0];
                 const parameters = [

package/dist/transformation/builtins/function.js

@@ -5,9 +5,9 @@ const CompilerOptions_1 = require("../../CompilerOptions");
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 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");
+const lua_ast_1 = require("../utils/lua-ast");
 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) {

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

@@ -1,4 +1,4 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-export declare function transformGlobalCall(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;
+export declare function tryTransformBuiltinGlobalCall(context: TransformationContext, node: ts.CallExpression, expressionType: ts.Type): lua.Expression | undefined;

package/dist/transformation/builtins/global.js

@@ -1,30 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformGlobalCall = void 0;
+exports.tryTransformBuiltinGlobalCall = void 0;
 const lualib_1 = require("../utils/lualib");
 const typescript_1 = require("../utils/typescript");
 const call_1 = require("../visitors/call");
-function transformGlobalCall(context, node) {
-    const signature = context.checker.getResolvedSignature(node);
-    const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
-    const expressionType = context.checker.getTypeAtLocation(node.expression);
+function tryTransformBuiltinGlobalCall(context, node, expressionType) {
+    function getParameters() {
+        const signature = context.checker.getResolvedSignature(node);
+        return (0, call_1.transformArguments)(context, node.arguments, signature);
+    }
     const name = expressionType.symbol.name;
     switch (name) {
         case "SymbolConstructor":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Symbol, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Symbol, node, ...getParameters());
         case "NumberConstructor":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, node, ...getParameters());
         case "isNaN":
         case "isFinite":
             const numberParameters = (0, typescript_1.isNumberType)(context, expressionType)
-                ? parameters
-                : [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, undefined, ...parameters)];
+                ? getParameters()
+                : [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, undefined, ...getParameters())];
             return (0, lualib_1.transformLuaLibFunction)(context, name === "isNaN" ? lualib_1.LuaLibFeature.NumberIsNaN : lualib_1.LuaLibFeature.NumberIsFinite, node, ...numberParameters);
         case "parseFloat":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseFloat, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseFloat, node, ...getParameters());
         case "parseInt":
-            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseInt, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseInt, node, ...getParameters());
     }
 }
-exports.transformGlobalCall = transformGlobalCall;
+exports.tryTransformBuiltinGlobalCall = tryTransformBuiltinGlobalCall;
 //# sourceMappingURL=global.js.map

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

@@ -2,6 +2,6 @@ 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, isOptionalCall: boolean): lua.Expression | undefined;
-export declare function transformBuiltinIdentifierExpression(context: TransformationContext, node: ts.Identifier): lua.Expression | undefined;
+export declare function transformBuiltinCallExpression(context: TransformationContext, node: ts.CallExpression): lua.Expression | undefined;
+export declare function transformBuiltinIdentifierExpression(context: TransformationContext, node: ts.Identifier, symbol: ts.Symbol | undefined): lua.Expression | undefined;
 export declare function checkForLuaLibType(context: TransformationContext, type: ts.Type): void;

package/dist/transformation/builtins/index.js

@@ -22,10 +22,10 @@ const diagnostics_1 = require("../utils/diagnostics");
 function transformBuiltinPropertyAccessExpression(context, node) {
     const ownerType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
-        switch (node.expression.text) {
+        switch (ownerType.symbol.name) {
             case "Math":
                 return (0, math_1.transformMathProperty)(context, node);
-            case "Symbol":
+            case "SymbolConstructor":
                 (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Symbol);
         }
     }
@@ -40,102 +40,95 @@ function transformBuiltinPropertyAccessExpression(context, node) {
     }
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
-function transformBuiltinCallExpression(context, node, isOptionalCall) {
-    const unsupportedOptionalCall = () => {
-        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        return lua.createNilLiteral();
-    };
+function transformBuiltinCallExpression(context, node) {
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         checkForLuaLibType(context, expressionType);
-        const result = (0, global_1.transformGlobalCall)(context, node);
-        if (result) {
-            if (isOptionalCall)
-                return unsupportedOptionalCall();
+        const result = (0, global_1.tryTransformBuiltinGlobalCall)(context, node, expressionType);
+        if (result)
             return result;
-        }
     }
     const calledMethod = ts.getOriginalNode((0, call_1.getCalledExpression)(node));
-    if (!ts.isPropertyAccessExpression(calledMethod)) {
-        return;
+    if (ts.isPropertyAccessExpression(calledMethod)) {
+        const globalResult = tryTransformBuiltinGlobalMethodCall(context, node, calledMethod);
+        if (globalResult)
+            return globalResult;
+        const prototypeResult = tryTransformBuiltinPropertyCall(context, node, calledMethod);
+        if (prototypeResult)
+            return prototypeResult;
+        // object prototype call may work even without resolved signature/type (which the other builtin calls use)
+        // e.g. (foo as any).toString()
+        // prototype methods take precedence (e.g. number.toString(2))
+        const objectResult = (0, object_1.tryTransformObjectPrototypeCall)(context, node, calledMethod);
+        if (objectResult)
+            return objectResult;
     }
-    const isOptionalAccess = calledMethod.questionDotToken;
-    // If the function being called is of type owner.func, get the type of owner
+}
+exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
+function tryTransformBuiltinGlobalMethodCall(context, node, calledMethod) {
     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, calledMethod);
-            case "Console":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, console_1.transformConsoleCall)(context, node, calledMethod);
-            case "Math":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, math_1.transformMathCall)(context, node, calledMethod);
-            case "StringConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, string_1.transformStringConstructorCall)(context, node, calledMethod);
-            case "ObjectConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, object_1.transformObjectConstructorCall)(context, node, calledMethod);
-            case "SymbolConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, symbol_1.transformSymbolConstructorCall)(context, node, calledMethod);
-            case "NumberConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, number_1.transformNumberConstructorCall)(context, node, calledMethod);
-            case "PromiseConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, promise_1.transformPromiseConstructorCall)(context, node, calledMethod);
-        }
-    }
-    const isStringFunction = (0, typescript_1.isStringType)(context, ownerType) ||
-        (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, calledMethod);
-    }
-    const isNumberFunction = (0, typescript_1.isNumberType)(context, ownerType) ||
-        (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, calledMethod);
-    }
-    const isArrayFunction = (0, typescript_1.isArrayType)(context, ownerType) ||
-        (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, calledMethod);
+    if (!(0, typescript_1.isStandardLibraryType)(context, ownerType, undefined))
+        return;
+    const ownerSymbol = ownerType.symbol;
+    if (!ownerSymbol || ownerSymbol.parent)
+        return;
+    let result;
+    switch (ownerSymbol.name) {
+        case "ArrayConstructor":
+            result = (0, array_1.transformArrayConstructorCall)(context, node, calledMethod);
+            break;
+        case "Console":
+            result = (0, console_1.transformConsoleCall)(context, node, calledMethod);
+            break;
+        case "Math":
+            result = (0, math_1.transformMathCall)(context, node, calledMethod);
+            break;
+        case "StringConstructor":
+            result = (0, string_1.transformStringConstructorCall)(context, node, calledMethod);
+            break;
+        case "ObjectConstructor":
+            result = (0, object_1.transformObjectConstructorCall)(context, node, calledMethod);
+            break;
+        case "SymbolConstructor":
+            result = (0, symbol_1.transformSymbolConstructorCall)(context, node, calledMethod);
+            break;
+        case "NumberConstructor":
+            result = (0, number_1.transformNumberConstructorCall)(context, node, calledMethod);
+            break;
+        case "PromiseConstructor":
+            result = (0, promise_1.transformPromiseConstructorCall)(context, node, calledMethod);
+            break;
     }
-    const isFunctionFunction = (0, typescript_1.isFunctionType)(ownerType) ||
-        (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, calledMethod);
+    if (result && calledMethod.questionDotToken) {
+        // e.g. console?.log()
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(calledMethod));
     }
-    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, calledMethod);
-    if (objectResult) {
-        if (isOptionalCall)
-            return unsupportedOptionalCall();
-        return objectResult;
+    return result;
+}
+function tryTransformBuiltinPropertyCall(context, node, calledMethod) {
+    var _a;
+    const signatureDeclaration = (_a = context.checker.getResolvedSignature(node)) === null || _a === void 0 ? void 0 : _a.declaration;
+    if (!signatureDeclaration || !(0, typescript_1.isStandardLibraryDeclaration)(context, signatureDeclaration))
+        return;
+    const callSymbol = context.checker.getTypeAtLocation(signatureDeclaration).symbol;
+    const ownerSymbol = callSymbol.parent;
+    if (!ownerSymbol || ownerSymbol.parent)
+        return;
+    switch (ownerSymbol.name) {
+        case "String":
+            return (0, string_1.transformStringPrototypeCall)(context, node, calledMethod);
+        case "Number":
+            return (0, number_1.transformNumberPrototypeCall)(context, node, calledMethod);
+        case "Array":
+        case "ReadonlyArray":
+            return (0, array_1.transformArrayPrototypeCall)(context, node, calledMethod);
+        case "Function":
+        case "CallableFunction":
+        case "NewableFunction":
+            return (0, function_1.transformFunctionPrototypeCall)(context, node, calledMethod);
     }
 }
-exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
-function transformBuiltinIdentifierExpression(context, node) {
+function transformBuiltinIdentifierExpression(context, node, symbol) {
     switch (node.text) {
         case "NaN":
             return (0, lua_ast_1.createNaN)(node);
@@ -144,7 +137,7 @@ function transformBuiltinIdentifierExpression(context, node) {
             const huge = lua.createStringLiteral("huge");
             return lua.createTableIndexExpression(math, huge, node);
         case "globalThis":
-            return lua.createIdentifier("_G", node, (0, symbols_1.getIdentifierSymbolId)(context, node), "globalThis");
+            return lua.createIdentifier("_G", node, (0, symbols_1.getIdentifierSymbolId)(context, node, symbol), "globalThis");
     }
 }
 exports.transformBuiltinIdentifierExpression = transformBuiltinIdentifierExpression;
@@ -163,9 +156,10 @@ const builtinErrorTypeNames = new Set([
     "URIErrorConstructor",
 ]);
 function checkForLuaLibType(context, type) {
-    if (!type.symbol)
+    const symbol = type.symbol;
+    if (!symbol || symbol.parent)
         return;
-    const name = context.checker.getFullyQualifiedName(type.symbol);
+    const name = symbol.name;
     switch (name) {
         case "Map":
         case "MapConstructor":
@@ -183,6 +177,10 @@ function checkForLuaLibType(context, type) {
         case "WeakSetConstructor":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.WeakSet);
             return;
+        case "Promise":
+        case "PromiseConstructor":
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
+            return;
     }
     if (builtinErrorTypeNames.has(name)) {
         (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Error);

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

@@ -2,4 +2,4 @@ import * as lua from "../../LuaAST";
 import * as ts from "typescript";
 import { TransformationContext } from "../context";
 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;
+export declare function tryTransformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;