lua: prepare utils for box error trace improvement

Here is just of bunch utility functions that used in the patch that make
several modules throw box.error with trace set to the caller place. That
patch is just a boring huge switch to box.error and setting proper level
on error creation. Factor out utility functions so that they and their
tests are not get lost.

Part of tarantool#9914

NO_CHANGELOG=internal
NO_DOC=internal

Author: nshy

src/box/lua/console.lua

@@ -28,6 +28,7 @@ local urilib = require('uri')
 local yaml = require('yaml')
 local net_box = require('net.box')
 local help = require('help').help
+local utils = require('internal.utils')
 
 local DEFAULT_CONNECT_TIMEOUT = 10
 local PUSH_TAG_HANDLE = '!push!'
@@ -413,13 +414,6 @@ local function get_command(line)
     return nil
 end
 
---
--- return args as table with 'n' set to args number
---
-local function table_pack(...)
-    return {n = select('#', ...), ...}
-end
-
 local initial_env
 
 -- Get initial console environment.
@@ -519,7 +513,7 @@ local function local_eval(storage, line)
     end
     -- box.is_in_txn() is stubbed to throw a error before call to box.cfg{}
     local in_txn_before = ffi.C.box_txn()
-    local res = table_pack(pcall(fun))
+    local res = utils.table_pack(pcall(fun))
     --
     -- Rollback if transaction was began in the failed expression.
     --

src/lua/utils.c

@@ -1135,3 +1135,95 @@ void cord_on_yield(void)
 		exit(EXIT_FAILURE);
 	}
 }
+
+const char *
+luaT_checkstring(struct lua_State *L, int index)
+{
+	const char *name = lua_tostring(L, index);
+	if (name == NULL) {
+		diag_set(IllegalParams, "expected string as %d argument",
+			 index);
+		luaT_error(L);
+	}
+	return name;
+}
+
+const char *
+luaT_checklstring(struct lua_State *L, int index, size_t *len)
+{
+	const char *name = lua_tolstring(L, index, len);
+	if (name == NULL) {
+		diag_set(IllegalParams, "expected string as %d argument",
+			 index);
+		luaT_error(L);
+	}
+	return name;
+}
+
+int
+luaT_checkint(struct lua_State *L, int index)
+{
+	int ok;
+	int i = lua_tointegerx(L, index, &ok);
+	if (!ok) {
+		diag_set(IllegalParams, "expected integer as %d argument",
+			 index);
+		luaT_error(L);
+	}
+	return i;
+}
+
+double
+luaT_checknumber(struct lua_State *L, int index)
+{
+	int ok;
+	double d = lua_tonumberx(L, index, &ok);
+	if (!ok) {
+		diag_set(IllegalParams, "expected number as %d argument",
+			 index);
+		luaT_error(L);
+	}
+	return d;
+}
+
+void *
+luaT_checkudata(struct lua_State *L, int index, const char *name)
+{
+	void *udata = luaL_testudata(L, index, name);
+	if (udata == NULL) {
+		diag_set(IllegalParams, "expected %s as %d argument",
+			 name, index);
+		luaT_error(L);
+	}
+	return udata;
+}
+
+void
+luaT_checktype(struct lua_State *L, int index, int expected)
+{
+	int actual = lua_type(L, index);
+	if (actual != expected) {
+		diag_set(IllegalParams, "expected %s as %d argument",
+			 lua_typename(L, expected), index);
+		luaT_error(L);
+	}
+}
+
+int64_t
+luaT_checkint64(struct lua_State *L, int idx)
+{
+	int64_t result;
+	if (luaL_convertint64(L, idx, false, &result) != 0) {
+		diag_set(IllegalParams, "expected int64_t as %d argument", idx);
+		luaT_error(L);
+	}
+	return result;
+}
+
+int
+luaT_optint(struct lua_State *L, int index, int deflt)
+{
+	if (lua_isnoneornil(L, index))
+		return deflt;
+	return luaT_checkint(L, index);
+}

src/lua/utils.h

@@ -54,6 +54,8 @@ extern "C" {
 #include <lj_meta.h>
 
 #include "lua/error.h"
+#include "error.h"
+#include "diag.h"
 
 struct lua_State;
 struct ibuf;
@@ -577,6 +579,38 @@ void luaL_iterator_delete(struct luaL_iterator *it);
 int
 tarantool_lua_utils_init(struct lua_State *L);
 
+/** Same as luaL_checkstring but raises box error. **/
+const char *
+luaT_checkstring(struct lua_State *L, int index);
+
+/** Same as luaL_checklstring but raises box error. **/
+const char *
+luaT_checklstring(struct lua_State *L, int index, size_t *len);
+
+/** Same as luaL_checkint but raises box error. **/
+int
+luaT_checkint(struct lua_State *L, int index);
+
+/** Same as luaL_checknumber but raises box error. **/
+double
+luaT_checknumber(struct lua_State *L, int index);
+
+/** Same as luaL_checkudata but raises box error. **/
+void *
+luaT_checkudata(struct lua_State *L, int index, const char *name);
+
+/** Same as luaL_checktype but raises box error. **/
+void
+luaT_checktype(struct lua_State *L, int index, int expected);
+
+/** Same as luaL_checkint64 but raises box error. **/
+int64_t
+luaT_checkint64(struct lua_State *L, int idx);
+
+/** Same as luaL_optint but raises box error. **/
+int
+luaT_optint(struct lua_State *L, int index, int deflt);
+
 #if defined(__cplusplus)
 } /* extern "C" */
 #endif /* defined(__cplusplus) */

src/lua/utils.lua

@@ -151,4 +151,43 @@ function utils.box_check_configured()
     end
 end
 
+-- Checks if value() is valid expression.
+function utils.is_callable(value)
+    if type(value) == 'function' then
+        return true
+    end
+    local mt = debug.getmetatable(value)
+    if mt ~= nil and type(mt.__call) == 'function' then
+        return true
+    end
+    return false
+end
+
+--
+-- Return args as table with 'n' set to args number.
+--
+function utils.table_pack(...)
+    return {n = select('#', ...), ...}
+end
+
+--
+-- Call fn with given variable number of arguments. In case of error
+-- if error is box.error then update trace frame to the given level.
+-- If level is nil then trace frame will not be updated.
+--
+function utils.call_at(level, fn, ...)
+    local res = utils.table_pack(pcall(fn, ...))
+    if not res[1] then
+        local err = res[2]
+        if box.error.is(err) then
+            box.error(err, level and level + 1)
+        else
+            -- Keep original trace and append trace of level + 1 as
+            -- in case of box.error.
+            error(tostring(err), level and level + 1)
+        end
+    end
+    return unpack(res, 2, res.n)
+end
+
 return utils

test/app-luatest/utils_test.lua

@@ -65,3 +65,67 @@ g.test_update_param_table = function()
         c = 'y',
     })
 end
+
+g.test_is_callable = function()
+    t.assert(utils.is_callable(function() end))
+    local functor = setmetatable({}, {
+        __call = function() end
+    })
+    t.assert(utils.is_callable(functor))
+    t.assert_not(utils.is_callable(1))
+    t.assert_not(utils.is_callable("foo"))
+end
+
+g.test_table_pack = function()
+    t.assert_equals(utils.table_pack(), {n = 0})
+    t.assert_equals(utils.table_pack(1), {n = 1, 1})
+    t.assert_equals(utils.table_pack(1, 2), {n = 2, 1, 2})
+    t.assert_equals(utils.table_pack(1, 2, nil), {n = 3, 1, 2})
+    t.assert_equals(utils.table_pack(1, 2, nil, 3), {n = 4, 1, 2, nil, 3})
+end
+
+g.test_call_at = function()
+    local f = function(...) return ... end
+    t.assert_equals(utils.call_at(1, f, nil))
+    t.assert_equals(utils.call_at(1, f, 1), 1)
+    t.assert_equals(utils.table_pack(utils.call_at(1, f, 1, 2)),
+                    utils.table_pack(1, 2))
+    t.assert_equals(utils.table_pack(utils.call_at(1, f, 1, 2, nil)),
+                    utils.table_pack(1, 2, nil))
+    t.assert_equals(utils.table_pack(utils.call_at(1, f, 1, 2, nil, 3)),
+                    utils.table_pack(1, 2, nil, 3))
+
+    local this_file = debug.getinfo(1, 'S').short_src
+    local line1 = debug.getinfo(1, 'l').currentline + 1
+    local f1 = function() box.error(box.error.UNKNOWN, 1) end
+    local line2 = debug.getinfo(1, 'l').currentline + 1
+    local f2 = function(level, ...) utils.call_at(level, f1, ...) end
+    local line3 = debug.getinfo(1, 'l').currentline + 1
+    local f3 = function(...) f2(...) end
+
+    local check_box_error = function(level, line)
+        local ok, err = pcall(f3, level)
+        t.assert_not(ok)
+        t.assert(box.error.is(err))
+        t.assert_equals(err.trace[1].file, this_file)
+        t.assert_equals(err.trace[1].line, line)
+    end
+
+    check_box_error(nil, line1)
+    check_box_error(1, line2)
+    check_box_error(2, line3)
+
+    line1 = debug.getinfo(1, 'l').currentline + 1
+    f1 = function() error('foo', 1) end
+
+    local check_box_error = function(level, line_src, line_level)
+        local ok, err = pcall(f3, level)
+        t.assert_not(ok)
+        t.assert_equals(tostring(err),
+                        string.format('%s:%s: %s:%s: foo',
+                        this_file, line_level, this_file, line_src))
+    end
+
+    check_box_error(1, line1, line2)
+    check_box_error(2, line1, line3)
+end