---
source: src/main.rs
expression: compiled
input_file: test-data/lua5.1-tests/errors.lua
---
print("testing errors");
global fn doit(s) {
    local f, msg = loadstring(s)
    if f == nil {
        return msg
    }
    local cond, msg = pcall(f)
    return (!cond) && msg
}
global fn checkmessage(prog, msg) {
    assert(string.find(doit(prog), msg, 1, true));
}
global fn checksyntax(prog, extra, token, line) {
    local msg = doit(prog)
    token = string.gsub(token, "(%p)", "%%%1")
    local pt = string.format(`^%%[string ".*"%%]:%d: .- near '%s'$`, line, token)
    assert(string.find(msg, pt));
    assert(string.find(msg, msg, 1, true));
}
assert(doit("error('hi', 0)") == 'hi');
assert(doit("error()") == nil);
assert(doit("unpack({}, 1, n=2^30)"));
assert(doit("a=math.sin()"));
assert(!doit("tostring(1)") && doit("tostring()"));
assert(doit("tonumber()"));
assert(doit("repeat until 1; a"));
checksyntax("break label", "", "label", 1);
assert(doit(";"));
assert(doit("a=1;;"));
assert(doit("return;;"));
assert(doit("assert(false)"));
assert(doit("assert(nil)"));
assert(doit("a=math.sin\n(3)"));
assert(doit("function a (... , ...) end"));
assert(doit("function a (, ...) end"));
checksyntax(`
  local a = {4

`, "'}' expected (to close '{' at line 1)", "<eof>", 3);
checkmessage("a=1; bbbb=2; a=math.sin(3)+bbbb(3)", "global 'bbbb'");
checkmessage("a=1; local a,bbbb=2,3; a = math.sin(1) and bbbb(3)", "local 'bbbb'");
checkmessage("a={}; do local a=1 end a:bbbb(3)", "method 'bbbb'");
checkmessage("local a={}; a.bbbb(3)", "field 'bbbb'");
assert(!string.find(doit("a={13}; local bbbb=1; a[bbbb](3)"), "'bbbb'"));
checkmessage("a={13}; local bbbb=1; a[bbbb](3)", "number");
aaa = nil
checkmessage("aaa.bbb:ddd(9)", "global 'aaa'");
checkmessage("local aaa={bbb=1}; aaa.bbb:ddd(9)", "field 'bbb'");
checkmessage("local aaa={bbb={}}; aaa.bbb:ddd(9)", "method 'ddd'");
checkmessage("local a,b,c; (function () a = b+1 end)()", "upvalue 'b'");
assert(!doit("local aaa={bbb={ddd=next}}; aaa.bbb:ddd(nil)"));
checkmessage("b=1; local aaa='a'; x=aaa+b", "local 'aaa'");
checkmessage("aaa={}; x=3/aaa", "global 'aaa'");
checkmessage("aaa='2'; b=nil;x=aaa*b", "global 'b'");
checkmessage("aaa={}; x=-aaa", "global 'aaa'");
assert(!string.find(doit("aaa={}; x=(aaa or aaa)+(aaa and aaa)"), "'aaa'"));
assert(!string.find(doit("aaa={}; (aaa or aaa)()"), "'aaa'"));
checkmessage(`aaa=9
repeat until 3==3
local x=math.sin(math.cos(3))
if math.sin(1) == x then return math.sin(1) end   -- tail call
local a,b = 1, {
  {x='a'..'b'..'c', y='b', z=x},
  {1,2,3,4,5} or 3+3<=3+3,
  3+1>3+1,
  {d = x and aaa[x or y]}}
`, "global 'aaa'");
checkmessage(`
local x,y = {},1
if math.sin(1) == 0 then return 3 end    -- return
x.a()`, "field 'a'");
checkmessage(`
prefix = nil
insert = nil
while 1 do  
  local a
  if nil then break end
  insert(prefix, a)
end`, "global 'insert'");
checkmessage(`  -- tail call
  return math.sin("a")
`, "'sin'");
checkmessage(`collectgarbage("nooption")`, "invalid option");
checkmessage(`x = print .. "a"`, "concatenate");
checkmessage("getmetatable(io.stdin).__gc()", "no value");
print('+');
global fn lineerror(s) {
    local err, msg = pcall(loadstring(s))
    local line = string.match(msg, ":(%d+):")
    return line && line + 0
}
assert(lineerror("local a\n for i=1,'a' do \n print(i) \n end") == 2);
assert(lineerror("\n local a \n for k,v in 3 \n do \n print(k) \n end") == 3);
assert(lineerror("\n\n for k,v in \n 3 \n do \n print(k) \n end") == 4);
assert(lineerror("function a.x.y ()\na=a+1\nend") == 1);
local p = `
function g() f() end
function f(x) error('a', X) end
g()
`
X = 3
assert(lineerror(p) == 3);
X = 0
assert(lineerror(p) == nil);
X = 1
assert(lineerror(p) == 2);
X = 2
assert(lineerror(p) == 1);
lineerror = nil
C = 0
local l = debug.getinfo(1, "l").currentline
global fn y() {
    C = C + 1
    y();
}
local fn checkstackmessage(m) {
    return (string.find(m, "^.-:%d+: stack overflow"))
}
assert(checkstackmessage(doit('y()')));
assert(checkstackmessage(doit('y()')));
assert(checkstackmessage(doit('y()')));
C = 0
local l1
local fn g() {
    l1 = debug.getinfo(1, "l").currentline
    y();
}
local _, stackmsg = xpcall(g, debug.traceback)
local stack = {}
for line with string.gmatch(stackmsg, "[^\n]*") {
    local curr = string.match(line, ":(%d+):")
    if curr {
        table.insert(stack, tonumber(curr));
    }
}
local i = 1
while stack[(i)] != l1 {
    assert(stack[(i)] == l);
    i = i + 1
}
assert(i > 15);
local res, msg = xpcall(error, error)
assert(!res && type(msg) == 'string');
local fn f(x) {
    if x == 0 {
        error('a\n');
    } else {
        local aux = fn () {
            return f(x - 1)
        }
        local a, b = xpcall(aux, aux)
        return a, b
    }
}
f(3);
global fn f() {
    error({
        msg = 'x'
    });
}
res, msg = xpcall(f, fn (r) {
    return {
        msg = r.msg .. 'y'
    }
})
assert(msg.msg == 'xy');
print('+');
checksyntax("syntax error", "", "error", 1);
checksyntax("1.000", "", "1.000", 1);
checksyntax("[[a]]", "", "[[a]]", 1);
checksyntax("'aa'", "", "'aa'", 1);
checksyntax("\255a = 1", "", "\255", 1);
doit('I = loadstring("a=9+"); a=3');
assert(a == 3 && I == nil);
print('+');
lim = 1000
if rawget(_G, "_soft") {
    lim = 100
}
for i = 1, lim {
    doit('a = ');
    doit('a = 4+nil');
}
local fn testrep(init, rep) {
    local s = "local a; " .. init .. string.rep(rep, 400)
    local a, b = loadstring(s)
    assert(!a && string.find(b, "syntax levels"));
}
testrep("a=", "{");
testrep("a=", "(");
testrep("", "a(");
testrep("", "do ");
testrep("", "while a do ");
testrep("", "if a then else ");
testrep("", "function foo () ");
testrep("a=", "a..");
testrep("a=", "a^");
local s = "function foo ()\n  local "
for j = 1, 70 {
    s = s .. "a" .. j .. ", "
}
s = s .. "b\n"
for j = 1, 70 {
    s = s .. "function foo" .. j .. " ()\n a" .. j .. "=3\n"
}
local a, b = loadstring(s)
assert(string.find(b, "line 3"));
s = "\nfunction foo ()\n  local "
for j = 1, 300 {
    s = s .. "a" .. j .. ", "
}
s = s .. "b\n"
local a, b = loadstring(s)
assert(string.find(b, "line 2"));
print('OK');