fix(promise): improve reason for unhandled rejection

Error in Lua is messy because of the `errfunc` in `lua_pcall`.
1. If reject reason by Promise, only append UnhandledPromiseRejection header;
2. If invoke error() in a function, prefer use the result caught by `pcall`
   as reason for UnhandledPromiseRejection.

Author: kevinhwang91

README.md

@@ -122,8 +122,8 @@ The environment in `Async.sync` function have been injected some new functions f
 enhancement:
 
 1. `await`: A reference of `Async.wait` function;
-2. `pcall`: Be compatible with LuaJIT and handle error throws by Promise;
-3. `xpcall`: Be compatible with LuaJIT and handle error throws by Promise;
+2. `pcall`: Be compatible with LuaJIT;
+3. `xpcall`: Be compatible with LuaJIT;
 
 `async` in JavaScript return Promise object only with single result, but may carry multiple results
 in Lua. The resolved result of Promise object return by `async` function will be packed into a table

lua/async.lua

@@ -1,8 +1,6 @@
 local promise = require('promise')
 local utils = require('promise-async.utils')
 local compat = require('promise-async.compat')
-local errFactory = require('promise-async.error')
-local shortSrc = debug.getinfo(1, 'S').short_src
 
 local asyncId = {'promise-async'}
 
@@ -33,42 +31,22 @@ local function apcall(f, ...)
             return true, ...
         end
         local err = select(1, ...)
-        return false, errFactory.isInstance(err) and err:peek() or err
+        return false, err
     end
 
     return result(compat.pcall(f, ...))
 end
 
-local function axpcall(f, msgh, ...)
-    return compat.xpcall(f, function(err)
-        return msgh(errFactory.isInstance(err) and err:peek() or err)
-    end, ...)
-end
-
 local function injectENV(fn)
     compat.setfenv(fn, setmetatable({
         await = Async.wait,
         pcall = apcall,
-        xpcall = axpcall
+        xpcall = compat.xpcall
     }, {
         __index = compat.getfenv(fn)
     }))
 end
 
-local function buildError(thread, level, err)
-    if not errFactory.isInstance(err) then
-        err = errFactory.new(err)
-        level = level + 1
-    end
-    local ok, value
-    repeat
-        ok, value = errFactory.format(thread, level, shortSrc)
-        level = level + 1
-        err:push(value)
-    until not ok
-    return err
-end
-
 ---Export wait function to someone needs
 ---@param executor fun()
 ---@return Promise
@@ -117,15 +95,15 @@ function Async.sync(executor)
     end)
 end
 
----Export wait function to someone needs, wait function actually have been injected as `async`
+---Export wait function to someone needs, wait function actually have been injected as `await`
 ---into the executor of async function
 ---@param p Promise|table
 ---@return ...
 function Async.wait(p)
     p = promise.resolve(p)
     local err, res = coroutine.yield(p)
     if err then
-        error(buildError(coroutine.running(), 2, res))
+        error(res, 0)
     elseif hasPacked(res) then
         return compat.unpack(res)
     else

lua/promise.lua

@@ -1,6 +1,8 @@
 local utils = require('promise-async.utils')
 
 local promiseId = {'promise-async'}
+local errFactory = require('promise-async.error')
+local shortSrc = debug.getinfo(1, 'S').short_src
 
 ---@diagnostic disable: undefined-doc-name
 ---@alias PromiseState
@@ -19,6 +21,7 @@ local REJECTED = 3
 ---@field queue table
 ---@field loop PromiseAsyncLoop
 ---@field needHandleRejection? boolean
+---@field err? PromiseAsyncError
 ---@overload fun(executor: PromiseExecutor): Promise
 local Promise = setmetatable({_id = promiseId}, {
     __call = function(self, executor)
@@ -74,11 +77,11 @@ function Promise.isInstance(o, typ)
     return (typ or type(o)) == 'table' and o._id == promiseId
 end
 
----must one time get `thenCall` field from `o`, can't call repeatedly.
+---must get `thenCall` field from `o` at one time, can't call repeatedly.
 ---@param o any
 ---@param typ? type
 ---@return function?
-function Promise.getThenable(o, typ)
+local function getThenable(o, typ)
     local thenCall
     if (typ or type(o)) == 'table' then
         thenCall = o.thenCall
@@ -89,6 +92,20 @@ function Promise.getThenable(o, typ)
     return thenCall
 end
 
+---@param err any
+---@return PromiseAsyncError
+local function buildError(err)
+    local o = errFactory.new(err)
+    local level = 3
+    local ok, value
+    repeat
+        ok, value = errFactory.format(coroutine.running(), level, shortSrc)
+        level = level + 1
+        o:push(value)
+    until not ok
+    return o
+end
+
 local resolvePromise, rejectPromise
 
 ---@param promise Promise
@@ -125,6 +142,7 @@ local function handleQueue(promise)
                 if ok then
                     resolvePromise(newPromise, res)
                 else
+                    newPromise.err = buildError(res)
                     rejectPromise(newPromise, res)
                 end
             end
@@ -171,6 +189,7 @@ local function wrapExecutor(promise, executor, self)
         ok, res = pcall(executor, resolve, reject)
     end
     if not ok and not called then
+        promise.err = buildError(res)
         reject(res)
     end
 end
@@ -182,13 +201,12 @@ local function handleRejection(promise)
     Promise.loop.nextIdle(function()
         if promise.needHandleRejection then
             promise.needHandleRejection = nil
-            local errFactory = require('promise-async.error')
-            local reason = promise.result
-            if not errFactory.isInstance(reason) then
-                reason = errFactory.new(reason)
+            local err = promise.err
+            if not err then
+                err = errFactory.new(promise.result)
             end
-            reason:unshift('UnhandledPromiseRejection with the reason:')
-            error(reason)
+            err:unshift('UnhandledPromiseRejection with the reason:')
+            error(err)
         end
     end)
 end
@@ -217,7 +235,7 @@ resolvePromise = function(promise, value)
             rejectPromise(promise, reason)
         end)
     else
-        local thenCall = Promise.getThenable(value, valueType)
+        local thenCall = getThenable(value, valueType)
         if thenCall then
             wrapExecutor(promise, thenCall, value)
         else
@@ -277,7 +295,7 @@ function Promise:finally(onFinally)
         return value
     end, function(reason)
         wrapFinally()
-        error(reason)
+        return Promise.reject(reason)
     end)
 end
 
@@ -289,7 +307,7 @@ function Promise.resolve(value)
         return value
     else
         local o = Promise.new(noop)
-        local thenCall = Promise.getThenable(value, typ)
+        local thenCall = getThenable(value, typ)
         if thenCall then
             wrapExecutor(o, thenCall, value)
         else