typescript-to-lua 1.23.0 → 1.24.0

package/dist/lualib/universal/lualib_bundle.lua

@@ -588,6 +588,12 @@ local function __TS__ArrayWith(self, index, value)
     return copy
 end
 
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
 local function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
@@ -607,12 +613,6 @@ local function __TS__InstanceOf(obj, classTbl)
     return false
 end
 
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end
-
 local function __TS__Class(self)
     local c = {prototype = {}}
     c.prototype.__index = c.prototype
@@ -620,35 +620,27 @@ local function __TS__Class(self)
     return c
 end
 
-local function __TS__FunctionBind(fn, ...)
-    local boundArgs = {...}
-    return function(____, ...)
-        local args = {...}
-        __TS__ArrayUnshift(
-            args,
-            __TS__Unpack(boundArgs)
-        )
-        return fn(__TS__Unpack(args))
-    end
-end
-
 local __TS__Promise
 do
-    local function promiseDeferred(self)
+    local function makeDeferredPromiseFactory()
         local resolve
         local reject
-        local promise = __TS__New(
-            __TS__Promise,
-            function(____, res, rej)
-                resolve = res
-                reject = rej
-            end
-        )
-        return {promise = promise, resolve = resolve, reject = reject}
+        local function executor(____, res, rej)
+            resolve = res
+            reject = rej
+        end
+        return function()
+            local promise = __TS__New(__TS__Promise, executor)
+            return promise, resolve, reject
+        end
+    end
+    local makeDeferredPromise = makeDeferredPromiseFactory()
+    local function isPromiseLike(value)
+        return __TS__InstanceOf(value, __TS__Promise)
     end
-    local function isPromiseLike(self, thing)
-        return __TS__InstanceOf(thing, __TS__Promise)
+    local function doNothing(self)
     end
+    local ____pcall = _G.pcall
     __TS__Promise = __TS__Class()
     __TS__Promise.name = "__TS__Promise"
     function __TS__Promise.prototype.____constructor(self, executor)
@@ -656,206 +648,176 @@ do
         self.fulfilledCallbacks = {}
         self.rejectedCallbacks = {}
         self.finallyCallbacks = {}
-        do
-            local function ____catch(e)
-                self:reject(e)
-            end
-            local ____try, ____hasReturned = pcall(function()
-                executor(
-                    nil,
-                    __TS__FunctionBind(self.resolve, self),
-                    __TS__FunctionBind(self.reject, self)
-                )
-            end)
-            if not ____try then
-                ____catch(____hasReturned)
-            end
+        local success, ____error = ____pcall(
+            executor,
+            nil,
+            function(____, v) return self:resolve(v) end,
+            function(____, err) return self:reject(err) end
+        )
+        if not success then
+            self:reject(____error)
         end
     end
-    function __TS__Promise.resolve(data)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
+    function __TS__Promise.resolve(value)
+        if __TS__InstanceOf(value, __TS__Promise) then
+            return value
+        end
+        local promise = __TS__New(__TS__Promise, doNothing)
         promise.state = 1
-        promise.value = data
+        promise.value = value
         return promise
     end
     function __TS__Promise.reject(reason)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
+        local promise = __TS__New(__TS__Promise, doNothing)
         promise.state = 2
         promise.rejectionReason = reason
         return promise
     end
     __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
-        local ____promiseDeferred_result_0 = promiseDeferred(nil)
-        local promise = ____promiseDeferred_result_0.promise
-        local resolve = ____promiseDeferred_result_0.resolve
-        local reject = ____promiseDeferred_result_0.reject
-        local isFulfilled = self.state == 1
-        local isRejected = self.state == 2
-        if onFulfilled then
-            local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
-            local ____self_fulfilledCallbacks_1 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_1[#____self_fulfilledCallbacks_1 + 1] = internalCallback
-            if isFulfilled then
-                internalCallback(nil, self.value)
-            end
-        else
-            local ____self_fulfilledCallbacks_2 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_2[#____self_fulfilledCallbacks_2 + 1] = function(____, v) return resolve(nil, v) end
-        end
-        if onRejected then
-            local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
-            local ____self_rejectedCallbacks_3 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_3[#____self_rejectedCallbacks_3 + 1] = internalCallback
-            if isRejected then
-                internalCallback(nil, self.rejectionReason)
-            end
-        else
-            local ____self_rejectedCallbacks_4 = self.rejectedCallbacks
-            ____self_rejectedCallbacks_4[#____self_rejectedCallbacks_4 + 1] = function(____, err) return reject(nil, err) end
-        end
-        if isFulfilled then
-            resolve(nil, self.value)
+        local promise, resolve, reject = makeDeferredPromise()
+        self:addCallbacks(
+            onFulfilled and self:createPromiseResolvingCallback(onFulfilled, resolve, reject) or resolve,
+            onRejected and self:createPromiseResolvingCallback(onRejected, resolve, reject) or reject
+        )
+        return promise
+    end
+    function __TS__Promise.prototype.addCallbacks(self, fulfilledCallback, rejectedCallback)
+        if self.state == 1 then
+            return fulfilledCallback(nil, self.value)
         end
-        if isRejected then
-            reject(nil, self.rejectionReason)
+        if self.state == 2 then
+            return rejectedCallback(nil, self.rejectionReason)
         end
-        return promise
+        local ____self_fulfilledCallbacks_0 = self.fulfilledCallbacks
+        ____self_fulfilledCallbacks_0[#____self_fulfilledCallbacks_0 + 1] = fulfilledCallback
+        local ____self_rejectedCallbacks_1 = self.rejectedCallbacks
+        ____self_rejectedCallbacks_1[#____self_rejectedCallbacks_1 + 1] = rejectedCallback
     end
     function __TS__Promise.prototype.catch(self, onRejected)
         return self["then"](self, nil, onRejected)
     end
     function __TS__Promise.prototype.finally(self, onFinally)
         if onFinally then
-            local ____self_finallyCallbacks_5 = self.finallyCallbacks
-            ____self_finallyCallbacks_5[#____self_finallyCallbacks_5 + 1] = onFinally
+            local ____self_finallyCallbacks_2 = self.finallyCallbacks
+            ____self_finallyCallbacks_2[#____self_finallyCallbacks_2 + 1] = onFinally
             if self.state ~= 0 then
                 onFinally(nil)
             end
         end
         return self
     end
-    function __TS__Promise.prototype.resolve(self, data)
-        if __TS__InstanceOf(data, __TS__Promise) then
-            data["then"](
-                data,
+    function __TS__Promise.prototype.resolve(self, value)
+        if isPromiseLike(value) then
+            return value:addCallbacks(
                 function(____, v) return self:resolve(v) end,
                 function(____, err) return self:reject(err) end
             )
-            return
         end
         if self.state == 0 then
             self.state = 1
-            self.value = data
-            for ____, callback in ipairs(self.fulfilledCallbacks) do
-                callback(nil, data)
-            end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
-            end
+            self.value = value
+            return self:invokeCallbacks(self.fulfilledCallbacks, value)
         end
     end
     function __TS__Promise.prototype.reject(self, reason)
         if self.state == 0 then
             self.state = 2
             self.rejectionReason = reason
-            for ____, callback in ipairs(self.rejectedCallbacks) do
-                callback(nil, reason)
+            return self:invokeCallbacks(self.rejectedCallbacks, reason)
+        end
+    end
+    function __TS__Promise.prototype.invokeCallbacks(self, callbacks, value)
+        local callbacksLength = #callbacks
+        local finallyCallbacks = self.finallyCallbacks
+        local finallyCallbacksLength = #finallyCallbacks
+        if callbacksLength ~= 0 then
+            for i = 1, callbacksLength - 1 do
+                callbacks[i](callbacks, value)
             end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
+            if finallyCallbacksLength == 0 then
+                return callbacks[callbacksLength](callbacks, value)
             end
+            callbacks[callbacksLength](callbacks, value)
+        end
+        if finallyCallbacksLength ~= 0 then
+            for i = 1, finallyCallbacksLength - 1 do
+                finallyCallbacks[i](finallyCallbacks)
+            end
+            return finallyCallbacks[finallyCallbacksLength](finallyCallbacks)
         end
     end
     function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
         return function(____, value)
-            do
-                local function ____catch(e)
-                    reject(nil, e)
-                end
-                local ____try, ____hasReturned = pcall(function()
-                    self:handleCallbackData(
-                        f(nil, value),
-                        resolve,
-                        reject
-                    )
-                end)
-                if not ____try then
-                    ____catch(____hasReturned)
-                end
+            local success, resultOrError = ____pcall(f, nil, value)
+            if not success then
+                return reject(nil, resultOrError)
             end
+            return self:handleCallbackValue(resultOrError, resolve, reject)
         end
     end
-    function __TS__Promise.prototype.handleCallbackData(self, data, resolve, reject)
-        if isPromiseLike(nil, data) then
-            local nextpromise = data
+    function __TS__Promise.prototype.handleCallbackValue(self, value, resolve, reject)
+        if isPromiseLike(value) then
+            local nextpromise = value
             if nextpromise.state == 1 then
-                resolve(nil, nextpromise.value)
+                return resolve(nil, nextpromise.value)
             elseif nextpromise.state == 2 then
-                reject(nil, nextpromise.rejectionReason)
+                return reject(nil, nextpromise.rejectionReason)
             else
-                data["then"](data, resolve, reject)
+                return nextpromise:addCallbacks(resolve, reject)
             end
         else
-            resolve(nil, data)
+            return resolve(nil, value)
         end
     end
 end
 
-local function __TS__AsyncAwaiter(generator)
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            local adopt, fulfilled, step, resolved, asyncCoroutine
-            function adopt(self, value)
-                return __TS__InstanceOf(value, __TS__Promise) and value or __TS__Promise.resolve(value)
-            end
-            function fulfilled(self, value)
-                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
-                if success then
-                    step(nil, resultOrError)
-                else
-                    reject(nil, resultOrError)
+local __TS__AsyncAwaiter, __TS__Await
+do
+    local cocreate = coroutine.create
+    local coresume = coroutine.resume
+    local costatus = coroutine.status
+    local coyield = coroutine.yield
+    function __TS__AsyncAwaiter(generator)
+        return __TS__New(
+            __TS__Promise,
+            function(____, resolve, reject)
+                local fulfilled, step, resolved, asyncCoroutine
+                function fulfilled(self, value)
+                    local success, resultOrError = coresume(asyncCoroutine, value)
+                    if success then
+                        return step(resultOrError)
+                    end
+                    return reject(nil, resultOrError)
                 end
-            end
-            function step(self, result)
-                if resolved then
-                    return
+                function step(result)
+                    if resolved then
+                        return
+                    end
+                    if costatus(asyncCoroutine) == "dead" then
+                        return resolve(nil, result)
+                    end
+                    return __TS__Promise.resolve(result):addCallbacks(fulfilled, reject)
                 end
-                if coroutine.status(asyncCoroutine) == "dead" then
-                    resolve(nil, result)
+                resolved = false
+                asyncCoroutine = cocreate(generator)
+                local success, resultOrError = coresume(
+                    asyncCoroutine,
+                    function(____, v)
+                        resolved = true
+                        return __TS__Promise.resolve(v):addCallbacks(resolve, reject)
+                    end
+                )
+                if success then
+                    return step(resultOrError)
                 else
-                    local ____self_0 = adopt(nil, result)
-                    ____self_0["then"](____self_0, fulfilled, reject)
+                    return reject(nil, resultOrError)
                 end
             end
-            resolved = false
-            asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(
-                asyncCoroutine,
-                function(____, v)
-                    resolved = true
-                    local ____self_1 = adopt(nil, v)
-                    ____self_1["then"](____self_1, resolve, reject)
-                end
-            )
-            if success then
-                step(nil, resultOrError)
-            else
-                reject(nil, resultOrError)
-            end
-        end
-    )
-end
-local function __TS__Await(thing)
-    return coroutine.yield(thing)
+        )
+    end
+    function __TS__Await(thing)
+        return coyield(thing)
+    end
 end
 
 local function __TS__ClassExtends(target, base)
@@ -953,20 +915,17 @@ local function __TS__ObjectGetOwnPropertyDescriptor(object, key)
     return rawget(metatable, "_descriptors")[key]
 end
 
-local __TS__SetDescriptor
+local __TS__DescriptorGet
 do
-    local function descriptorIndex(self, key)
-        local value = rawget(self, key)
-        if value ~= nil then
-            return value
-        end
-        local metatable = getmetatable(self)
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    function __TS__DescriptorGet(self, metatable, key)
         while metatable do
-            local rawResult = rawget(metatable, key)
+            local rawResult = ____rawget(metatable, key)
             if rawResult ~= nil then
                 return rawResult
             end
-            local descriptors = rawget(metatable, "_descriptors")
+            local descriptors = ____rawget(metatable, "_descriptors")
             if descriptors then
                 local descriptor = descriptors[key]
                 if descriptor ~= nil then
@@ -979,10 +938,16 @@ do
             metatable = getmetatable(metatable)
         end
     end
-    local function descriptorNewIndex(self, key, value)
-        local metatable = getmetatable(self)
+end
+
+local __TS__DescriptorSet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    local rawset = _G.rawset
+    function __TS__DescriptorSet(self, metatable, key, value)
         while metatable do
-            local descriptors = rawget(metatable, "_descriptors")
+            local descriptors = ____rawget(metatable, "_descriptors")
             if descriptors then
                 local descriptor = descriptors[key]
                 if descriptor ~= nil then
@@ -1004,6 +969,26 @@ do
         end
         rawset(self, key, value)
     end
+end
+
+local __TS__SetDescriptor
+do
+    local getmetatable = _G.getmetatable
+    local function descriptorIndex(self, key)
+        return __TS__DescriptorGet(
+            self,
+            getmetatable(self),
+            key
+        )
+    end
+    local function descriptorNewIndex(self, key, value)
+        return __TS__DescriptorSet(
+            self,
+            getmetatable(self),
+            key,
+            value
+        )
+    end
     function __TS__SetDescriptor(target, key, desc, isPrototype)
         if isPrototype == nil then
             isPrototype = false
@@ -1232,6 +1217,18 @@ local function __TS__DelegatedYield(iterable)
     end
 end
 
+local function __TS__FunctionBind(fn, ...)
+    local boundArgs = {...}
+    return function(____, ...)
+        local args = {...}
+        __TS__ArrayUnshift(
+            args,
+            __TS__Unpack(boundArgs)
+        )
+        return fn(__TS__Unpack(args))
+    end
+end
+
 local __TS__Generator
 do
     local function generatorIterator(self)
@@ -2551,6 +2548,8 @@ return {
   __TS__DecorateParam = __TS__DecorateParam,
   __TS__Delete = __TS__Delete,
   __TS__DelegatedYield = __TS__DelegatedYield,
+  __TS__DescriptorGet = __TS__DescriptorGet,
+  __TS__DescriptorSet = __TS__DescriptorSet,
   Error = Error,
   RangeError = RangeError,
   ReferenceError = ReferenceError,

package/dist/lualib/universal/lualib_module_info.json

@@ -210,7 +210,6 @@
       "__TS__Await"
     ],
     "dependencies": [
-      "InstanceOf",
       "Promise",
       "New"
     ]
@@ -277,6 +276,16 @@
       "Symbol"
     ]
   },
+  "DescriptorGet": {
+    "exports": [
+      "__TS__DescriptorGet"
+    ]
+  },
+  "DescriptorSet": {
+    "exports": [
+      "__TS__DescriptorSet"
+    ]
+  },
   "Error": {
     "exports": [
       "Error",
@@ -491,8 +500,7 @@
       "Promise",
       "New",
       "InstanceOf",
-      "Class",
-      "FunctionBind"
+      "Class"
     ]
   },
   "PromiseAll": {
@@ -554,7 +562,9 @@
       "__TS__SetDescriptor"
     ],
     "dependencies": [
-      "CloneDescriptor"
+      "CloneDescriptor",
+      "DescriptorGet",
+      "DescriptorSet"
     ]
   },
   "SparseArrayNew": {

package/dist/transformation/visitors/access.js

@@ -15,6 +15,7 @@ const expression_list_1 = require("./expression-list");
 const call_extension_1 = require("./language-extensions/call-extension");
 const multi_1 = require("./language-extensions/multi");
 const optional_chaining_1 = require("./optional-chaining");
+const typescript_2 = require("typescript");
 function addOneToArrayAccessArgument(context, node, index) {
     const type = context.checker.getTypeAtLocation(node.expression);
     const argumentType = context.checker.getTypeAtLocation(node.argumentExpression);
@@ -128,6 +129,11 @@ function transformPropertyAccessExpressionWithCapture(context, node, thisValueCa
             thisValue,
         };
     }
+    if (node.expression.kind === typescript_2.SyntaxKind.SuperKeyword) {
+        return {
+            expression: (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.DescriptorGet, node, lua.createIdentifier("self"), table, lua.createStringLiteral(property)),
+        };
+    }
     return { expression: lua.createTableIndexExpression(table, lua.createStringLiteral(property), node) };
 }
 exports.transformPropertyAccessExpressionWithCapture = transformPropertyAccessExpressionWithCapture;

package/dist/transformation/visitors/binary-expression/assignments.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformAssignmentStatement = exports.transformAssignmentExpression = exports.transformAssignmentWithRightPrecedingStatements = exports.transformAssignment = exports.transformAssignmentLeftHandSideExpression = void 0;
 const ts = require("typescript");
+const typescript_1 = require("typescript");
 const lua = require("../../../LuaAST");
 const assignment_validation_1 = require("../../utils/assignment-validation");
 const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const lualib_1 = require("../../utils/lualib");
-const typescript_1 = require("../../utils/typescript");
+const typescript_2 = require("../../utils/typescript");
 const destructuring_assignments_1 = require("./destructuring-assignments");
 const multi_1 = require("../language-extensions/multi");
 const diagnostics_1 = require("../../utils/diagnostics");
@@ -54,6 +55,15 @@ lhs, right, rightHasPrecedingStatements, parent) {
         const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
         return [arrayLengthAssignment];
     }
+    if (ts.isPropertyAccessExpression(lhs) || ts.isElementAccessExpression(lhs)) {
+        if (lhs.expression.kind === typescript_1.SyntaxKind.SuperKeyword) {
+            return [
+                lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.DescriptorSet, parent, lua.createIdentifier("self"), context.transformExpression(lhs.expression), ts.isPropertyAccessExpression(lhs)
+                    ? lua.createStringLiteral(lhs.name.text)
+                    : context.transformExpression(lhs.argumentExpression), right)),
+            ];
+        }
+    }
     const symbol = lhs.parent && ts.isShorthandPropertyAssignment(lhs.parent)
         ? context.checker.getShorthandAssignmentValueSymbol(lhs.parent)
         : context.checker.getSymbolAtLocation(lhs);
@@ -96,7 +106,7 @@ function transformAssignmentExpression(context, expression) {
         // array.length = x
         return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
     }
-    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
+    if ((0, typescript_2.isDestructuringAssignment)(expression)) {
         const { statements, result } = transformDestructuredAssignmentExpression(context, expression);
         context.addPrecedingStatements(statements);
         return result;
@@ -142,7 +152,7 @@ function transformAssignmentStatement(context, expression) {
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
     (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
-    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
+    if ((0, typescript_2.isDestructuringAssignment)(expression)) {
         if (canBeTransformedToLuaAssignmentStatement(context, expression)) {
             const rightType = context.checker.getTypeAtLocation(expression.right);
             let right;
@@ -151,7 +161,7 @@ function transformAssignmentStatement(context, expression) {
             }
             else {
                 right = context.transformExpression(expression.right);
-                if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_1.isArrayType)(context, rightType)) {
+                if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_2.isArrayType)(context, rightType)) {
                     right = (0, lua_ast_1.createUnpackCall)(context, right, expression.right);
                 }
             }

package/package.json

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