---
source: src/main.rs
expression: compiled
input_file: test-data/lua5.4-tests/vararg.lua
---
print('testing vararg');
global fn f(a, ...) {
    local x = {
        n = select('#', ...), 
        ...
    }
    for i = 1, x.n {
        assert(a[(i)] == x[(i)]);
    }
    return x.n
}
global fn c12(...) {
    assert(arg == _G.arg);
    local x = {
        ...
    }
    x.n = #x
    local res = (x.n == 2 && x[(1)] == 1 && x[(2)] == 2)
    if res {
        res = 55
    }
    return res, 2
}
global fn vararg(...) {
    return {
        n = select('#', ...), 
        ...
    }
}
local call = fn (f, args) {
    return f(table.unpack(args, 1, args.n))
}
assert(f() == 0);
assert(f({
    1, 
    2, 
    3
}, 1, 2, 3) == 3);
assert(f({
    "alo", 
    nil, 
    45, 
    f, 
    nil
}, "alo", nil, 45, f, nil) == 5);
assert(vararg().n == 0);
assert(vararg(nil, nil).n == 2);
assert(c12(1, 2) == 55);
a, b = assert(call(c12, {
    1, 
    2
}))
assert(a == 55 && b == 2);
a = call(c12, {
    1, 
    2, 
    n = 2
})
assert(a == 55 && b == 2);
a = call(c12, {
    1, 
    2, 
    n = 1
})
assert(!a);
assert(c12(1, 2, 3) == false);
local a = vararg(call(next, {
    _G, 
    nil, 
    n = 2
}))
local b, c = next(_G)
assert(a[(1)] == b && a[(2)] == c && a.n == 2);
a = vararg(call(call, {
    c12, 
    {
        1, 
        2
    }
}))
assert(a.n == 2 && a[(1)] == 55 && a[(2)] == 2);
a = call(print, {
    '+'
})
assert(a == nil);
local t = {
    1, 
    10
}
method t::f(...) {
    local arg = {
        ...
    }
    return self[(...)] + #arg
}
assert(t::f(1, 4) == 3 && t::f(2) == 11);
print('+');
lim = 20
local i, a = 1, {}
while i <= lim {
    a[(i)] = i + 0.3
    i = i + 1
}
global fn f(a, b, c, d, ...) {
    local more = {
        ...
    }
    assert(a == 1.3 && more[(1)] == 5.3 && more[(lim - 4)] == lim + 0.3 && !more[(lim - 3)]);
}
global fn g(a, b, c) {
    assert(a == 1.3 && b == 2.3 && c == 3.3);
}
call(f, a);
call(g, a);
a = {}
i = 1
while i <= lim {
    a[(i)] = i
    i = i + 1
}
assert(call(math.max, a) == lim);
print("+");
global fn oneless(a, ...) {
    return ...
}
global fn f(n, a, ...) {
    local b
    assert(arg == _G.arg);
    if n == 0 {
        local b, c, d = ...
        return a, b, c, d, oneless(oneless(oneless(...)))
    } else {
        n, b, a = n - 1, ..., a
        assert(b == ...);
        return f(n, a, ...)
    }
}
a, b, c, d, e = assert(f(10, 5, 4, 3, 2, 1))
assert(a == 5 && b == 4 && c == 3 && d == 2 && e == 1);
a, b, c, d, e = f(4)
assert(a == nil && b == nil && c == nil && d == nil && e == nil);
f = load([[ return {...} ]])
x = f(2, 3)
assert(x[(1)] == 2 && x[(2)] == 3 && x[(3)] == undef);
f = load([[
  local x = {...}
  for i=1,select('#', ...) do assert(x[i] == select(i, ...)) end
  assert(x[select('#', ...)+1] == undef)
  return true
]])
assert(f("a", "b", nil, {}, assert));
assert(f());
a = {
    select(3, table.unpack({
        10, 
        20, 
        30, 
        40
    }))
}
assert(#a == 2 && a[(1)] == 30 && a[(2)] == 40);
a = {
    select(1)
}
assert(next(a) == nil);
a = {
    select(-1, 3, 5, 7)
}
assert(a[(1)] == 7 && a[(2)] == undef);
a = {
    select(-2, 3, 5, 7)
}
assert(a[(1)] == 5 && a[(2)] == 7 && a[(3)] == undef);
pcall(select, 10000);
pcall(select, -10000);
global fn f(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, p44, p45, p46, p48, p49, p50, ...) {
    local a1, a2, a3, a4, a5, a6, a7
    local a8, a9, a10, a11, a12, a13, a14
}
f();
{
    local fn f(a, b, c) {
        return c, b
    }
    local fn g() {
        return f(1, 2)
    }
    local a, b = g()
    assert(a == nil && b == 2);
}
print('OK');