error: set trace of caller for API written in LuaC

In scope of the tarantool#9914 issue we are setting error trace for API to the
caller frame. For the API written in LuaC without any Lua code around
it is easy task. Just make `luaT_error` set the proper trace.

By the way test we don't mess up trace for code evaluated thru netbox.

Part of tarantool#9914

NO_CHANGELOG=incomplete
NO_DOC=incomplete

Author: nshy

src/box/lua/call.c

@@ -447,7 +447,7 @@ execute_lua_eval(lua_State *L)
 	uint32_t expr_len = ctx->name_len;
 	if (luaL_loadbuffer(L, expr, expr_len, "=eval")) {
 		diag_set(LuajitError, lua_tostring(L, -1));
-		luaT_error(L);
+		luaT_error_at(L, 0);
 	}
 
 	/* Unpack arguments */

src/box/lua/error.cc

@@ -118,33 +118,6 @@ error_create_table_case_get_reason(lua_State *L, int index,
 	return reason != NULL ? reason : "";
 }
 
-/**
- * Set the error location information (file, line) to Lua stack frame at
- * the given level. Level 1 is the Lua function that called this function.
- * If level is <= 0 or the function failed to get the location information,
- * the location is cleared.
- */
-static void
-set_error_trace(lua_State *L, int level, struct error *error)
-{
-	const char *file = "";
-	unsigned line = 0;
-	lua_Debug info;
-	if (level > 0 &&
-	    lua_getstack(L, level, &info) &&
-	    lua_getinfo(L, "Sl", &info)) {
-		if (*info.short_src) {
-			file = info.short_src;
-		} else if (*info.source) {
-			file = info.source;
-		} else {
-			file = "eval";
-		}
-		line = info.currentline;
-	}
-	error_set_location(error, file, line);
-}
-
 /**
  * Parse Lua arguments (they can come as single table or as
  * separate members) and construct struct error with given values.
@@ -256,7 +229,7 @@ luaT_error_create(lua_State *L, int top_base)
 raise:
 	struct error *error;
 	error = box_error_new(NULL, 0, code, custom_type, "%s", reason);
-	set_error_trace(L, level, error);
+	luaT_error_set_trace(L, level, error);
 	/*
 	 * Set the previous error, if it was specified.
 	 */
@@ -322,17 +295,18 @@ luaT_error_call(lua_State *L)
 			if (lua_type(L, 3) != LUA_TNUMBER)
 				goto bad_arg;
 			int level = lua_tointeger(L, 3);
-			set_error_trace(L, level, e);
+			luaT_error_set_trace(L, level, e);
 		}
 	} else {
 		e = luaT_error_create(L, 2);
 		if (e == NULL)
 			goto bad_arg;
 	}
 	diag_set_error(&fiber()->diag, e);
-	return luaT_error(L);
+	return luaT_error_at(L, 0);
 bad_arg:
-	return luaL_error(L, "box.error(): bad arguments");
+	diag_set(IllegalParams, "box.error(): bad arguments");
+	return luaT_error(L);
 }
 
 static int

src/lua/error.c

@@ -93,17 +93,46 @@ luaT_pusherror(struct lua_State *L, struct error *e)
 	luaL_setcdatagc(L, -2);
 }
 
+void
+luaT_error_set_trace(lua_State *L, int level, struct error *error)
+{
+	const char *file = "";
+	unsigned line = 0;
+	lua_Debug info;
+	if (level > 0 &&
+	    lua_getstack(L, level, &info) &&
+	    lua_getinfo(L, "Sl", &info)) {
+		if (*info.short_src) {
+			file = info.short_src;
+		} else if (*info.source) {
+			file = info.source;
+		} else {
+			file = "eval";
+		}
+		line = info.currentline;
+	}
+	error_set_location(error, file, line);
+}
+
 int
-luaT_error(lua_State *L)
+luaT_error_at(lua_State *L, int level)
 {
 	struct error *e = diag_last_error(&fiber()->diag);
 	assert(e != NULL);
+	if (level > 0)
+		luaT_error_set_trace(L, level, e);
 	luaT_pusherror(L, e);
 	lua_error(L);
 	unreachable();
 	return 0;
 }
 
+int
+luaT_error(lua_State *L)
+{
+	return luaT_error_at(L, 1);
+}
+
 int
 luaT_push_nil_and_error(lua_State *L)
 {

src/lua/error.h

@@ -43,13 +43,23 @@ extern uint32_t CTID_CONST_STRUCT_ERROR_REF;
 struct error;
 
 /**
- * Re-throws the last Tarantool error as a Lua object.
+ * Re-throws the last Tarantool error as a Lua object. Set trace frame
+ * of to the caller of Lua C API.
+ *
  * \sa lua_error()
  * \sa box_error_last()
  */
 LUA_API int
 luaT_error(lua_State *L);
 
+/**
+ * Same as luaT_error but set error trace frame according to given level.
+ * luaT_error same as this function with level equal to 1. If level is 0
+ * then error trace is unchanged.
+ */
+int
+luaT_error_at(lua_State *L, int level);
+
 /**
  * Return nil as the first return value and an error as the
  * second. The error is received using box_error_last().
@@ -78,6 +88,15 @@ luaL_checkerror(struct lua_State *L, int narg);
 void
 tarantool_lua_error_init(struct lua_State *L);
 
+/**
+ * Set the error location information (file, line) to Lua stack frame at
+ * the given level. Level 1 is the Lua function that called this function.
+ * If level is <= 0 or the function failed to get the location information,
+ * the location is cleared.
+ */
+void
+luaT_error_set_trace(lua_State *L, int level, struct error *error);
+
 #if defined(__cplusplus)
 } /* extern "C" */
 #endif /* defined(__cplusplus) */

test/box-luatest/error_subsystem_improvements_test.lua

@@ -1050,3 +1050,37 @@ g.test_illegal_params = function()
     t.assert_equals(e.type, 'IllegalParams')
     t.assert_equals(e.message, 'foo')
 end
+
+g.test_netbox_call_trace = function(cg)
+    local netbox = require('net.box')
+    local file = debug.getinfo(1, 'S').short_src
+    local line = debug.getinfo(1, 'l').currentline + 4
+    cg.server:exec(function()
+        box.schema.create_space('test')
+        rawset(_G, 'test_func', function()
+            box.space.test:insert({})
+        end)
+    end)
+
+    local function test_error(file, line, fn, ...)
+        local ok, err = pcall(fn, ...)
+        t.assert_not(ok)
+        t.assert(box.error.is(err))
+        t.assert_equals(err.message, "No index #0 is defined in space 'test'")
+        local trace = err.trace[1]
+        t.assert_equals(trace.line, line)
+        t.assert_equals(trace.file, file)
+    end
+
+    local c = netbox.connect(cg.server.net_box_uri)
+    test_error('eval', 3, c.eval, c, '\n\nbox.space.test:insert({})')
+    test_error(file, line, c.call, c, 'test_func')
+end
+
+g.after_test('test_netbox_call_trace', function(cg)
+    cg.server:exec(function()
+        if box.space.test ~= nil then
+            box.space.test:drop()
+        end
+    end)
+end)

test/unit/CMakeLists.txt

@@ -638,6 +638,15 @@ create_unit_test(PREFIX lua_utils
                            ${READLINE_LIBRARIES}
 )
 
+create_unit_test(PREFIX lua_error
+                 SOURCES lua_error.c
+                 LIBRARIES unit core server
+                           ${LUAJIT_LIBRARIES}
+                           ${CURL_LIBRARIES}
+                           ${LIBYAML_LIBRARIES}
+                           ${READLINE_LIBRARIES}
+)
+
 create_unit_test(PREFIX lua_msgpack
                  SOURCES lua_msgpack.c
                  LIBRARIES unit core server

test/unit/lua_error.c

@@ -0,0 +1,116 @@
+#include <stdio.h>
+
+#include "diag.h"
+#include "fiber.h"
+#include "lualib.h"
+#include "memory.h"
+
+#include "lua/error.h"
+#include "lua/utils.h"
+
+#define UNIT_TAP_COMPATIBLE 1
+#include "unit.h"
+
+static int
+raise_error(lua_State *L)
+{
+	diag_set(IllegalParams, "foo");
+	return luaT_error(L);
+}
+
+static int
+raise_error_at(lua_State *L)
+{
+	int level = lua_tointeger(L, 1);
+	diag_set(IllegalParams, "bar");
+	return luaT_error_at(L, level);
+}
+
+static int
+error_trace(lua_State *L)
+{
+	struct error *e = luaL_checkerror(L, 1);
+
+	lua_createtable(L, 0, 2);
+	lua_pushstring(L, "file");
+	lua_pushstring(L, e->file);
+	lua_settable(L, -3);
+	lua_pushstring(L, "line");
+	lua_pushinteger(L, e->line);
+	lua_settable(L, -3);
+	return 1;
+}
+
+const char *test_error_lua =
+"local this_file = debug.getinfo(1, 'S').short_src\n"
+"local line1 = debug.getinfo(1, 'l').currentline + 1\n"
+"local f1 = function(fn, ...) fn(...) end\n"
+"local line2 = debug.getinfo(1, 'l').currentline + 1\n"
+"local f2 = function(fn, ...) f1(fn, ...) end\n"
+"local line3 = debug.getinfo(1, 'l').currentline + 1\n"
+"local f3 = function(fn, ...) f2(fn, ...) end\n"
+"\n"
+"local function check(line, fn, ...)\n"
+"    local ok, err = pcall(f3, fn, ...)\n"
+"\n"
+"    assert(not ok, string.format('got %s', err))\n"
+"    local trace = test_error_trace(err)\n"
+"    assert(trace.file == this_file, string.format('got \"%s\"', trace.file))\n"
+"    assert(trace.line == line,\n"
+"           string.format('expected %d, got %d', line, trace.line))\n"
+"end\n"
+"\n"
+"assert(test_raise_error ~= nil)"
+"check(line1, test_raise_error)\n"
+"check(line1, test_raise_error_at, 1)\n"
+"check(line2, test_raise_error_at, 2)\n"
+"check(line3, test_raise_error_at, 3)\n"
+"\n"
+"local ok, err = pcall(f3, test_raise_error_at, 0)\n"
+"assert(not ok, string.format('got %s', err))\n"
+"local trace = test_error_trace(err)\n"
+"assert(string.find(trace.file, 'lua_error%.c') ~= nil,\n"
+"       string.format('got %s', trace.file))\n";
+
+static void
+test_error(lua_State *L)
+{
+	plan(1);
+	header();
+
+	int rc;
+
+	lua_pushcfunction(L, raise_error);
+	lua_setglobal(L, "test_raise_error");
+	lua_pushcfunction(L, raise_error_at);
+	lua_setglobal(L, "test_raise_error_at");
+	lua_pushcfunction(L, error_trace);
+	lua_setglobal(L, "test_error_trace");
+
+	rc = luaT_dostring(L, test_error_lua);
+	ok(rc == 0, rc == 0 ? "OK" : "got %s",
+	   diag_last_error(diag_get())->errmsg);
+
+	footer();
+	check_plan();
+}
+
+int
+main(void)
+{
+	plan(1);
+	header();
+
+	struct lua_State *L = luaL_newstate();
+	luaL_openlibs(L);
+	memory_init();
+	tarantool_lua_error_init(L);
+
+	test_error(L);
+
+	memory_free();
+	lua_close(L);
+
+	footer();
+	return check_plan();
+}