plainleaf/client/space_lua/eval.test.ts

import { assertEquals } from "@std/assert/equals";
import {
  LuaEnv,
  LuaNativeJSFunction,
  LuaStackFrame,
  LuaTable,
  luaValueToJS,
  singleResult,
} from "./runtime.ts";
import { parse } from "./parse.ts";
import type { LuaBlock, LuaFunctionCallStatement } from "./ast.ts";
import { evalExpression, evalStatement } from "./eval.ts";
import { luaBuildStandardEnv } from "./stdlib.ts";

const sf = LuaStackFrame.lostFrame;

function evalExpr(s: string, e = new LuaEnv(), sf?: LuaStackFrame): any {
  const node = parse(`e(${s})`).statements[0] as LuaFunctionCallStatement;
  sf = sf || new LuaStackFrame(e, node.ctx);
  return evalExpression(
    node.call.args[0],
    e,
    sf,
  );
}

async function evalBlock(s: string, e = new LuaEnv()): Promise<void> {
  const node = parse(s) as LuaBlock;
  const sf = new LuaStackFrame(e, node.ctx);
  await evalStatement(node, e, sf);
}

Deno.test("Evaluator test", async () => {
  const env = new LuaEnv();
  env.set("test", new LuaNativeJSFunction((n) => n));
  env.set("asyncTest", new LuaNativeJSFunction((n) => Promise.resolve(n)));

  // Basic arithmetic
  assertEquals(evalExpr(`1 + 2 + 3 - 3`), 3);
  assertEquals(evalExpr(`4 // 3`), 1);
  assertEquals(evalExpr(`4 % 3`), 1);

  // Bitwise arithmetic
  assertEquals(evalExpr(`~171`), -172); // signed two's complement
  assertEquals(evalExpr(`5 & 3`), 1); // 101 & 011 = 001
  assertEquals(evalExpr(`5 | 3`), 7); // 101 | 011 = 111
  assertEquals(evalExpr(`5 ~ 3`), 6); // 101 ^ 011 = 110
  assertEquals(evalExpr(`5 << 3`), 40); // 101 << 3 = 101000
  assertEquals(evalExpr(`5 >> 2`), 1); // 101 >> 2 = 1

  // Strings
  assertEquals(evalExpr(`"a" .. "b"`), "ab");

  // Logic
  assertEquals(evalExpr(`true and false`), false);
  assertEquals(evalExpr(`true or false`), true);
  assertEquals(evalExpr(`not true`), false);
  // Test eager evaluation of left operand
  assertEquals(
    evalExpr(
      `true or (function() error("this should not be evaluated") end)()`,
    ),
    true,
  );
  // Tables
  const tbl = await evalExpr(`{3, 1, 2}`);
  assertEquals(tbl.get(1), 3);
  assertEquals(tbl.get(2), 1);
  assertEquals(tbl.get(3), 2);
  assertEquals(luaValueToJS(tbl, sf), [3, 1, 2]);

  assertEquals(
    luaValueToJS(await evalExpr(`{name=test("Zef"), age=100}`, env), sf),
    {
      name: "Zef",
      age: 100,
    },
  );

  assertEquals(
    luaValueToJS(await evalExpr(`{name="Zef", age=asyncTest(100)}`, env), sf),
    {
      name: "Zef",
      age: 100,
    },
  );

  const result = await evalExpr(`{[3+2]=1, ["a".."b"]=2}`);
  assertEquals(result.get(5), 1);
  assertEquals(result.get("ab"), 2);

  assertEquals(await evalExpr(`#{}`), 0);
  assertEquals(await evalExpr(`#{1, 2, 3}`), 3);

  // Unary operators
  assertEquals(await evalExpr(`-asyncTest(3)`, env), -3);

  // Function calls
  assertEquals(singleResult(evalExpr(`test(3)`, env)), 3);
  assertEquals(singleResult(await evalExpr(`asyncTest(3) + 1`, env)), 4);

  // Function expressions and table access
  assertEquals(
    await evalExpr(`(function() return {name="John"} end)().name`),
    "John",
  );

  // Function definitions
  const fn = evalExpr(`function(a, b) return a + b end`);
  assertEquals(fn.body.parameters, ["a", "b"]);
});

Deno.test("Parser rejects unary plus - parenthesized", () => {
  for (
    const src of [
      "return +(1)",
      "return +((1))",
      "return +(1 + 2)",
      "return +({})",
    ]
  ) {
    let err: any = null;
    try {
      parse(src);
    } catch (e: any) {
      err = e;
    }
    assertEquals(err !== null, true, `expected parse error for: ${src}`);
    assertEquals(
      String(err?.message ?? err).includes("unexpected symbol near '+'"),
      true,
      `expected unary-plus message for: ${src}`,
    );
  }
});

Deno.test("Parser rejects unary plus - variables and calls", () => {
  for (
    const src of [
      "return +(a)",
      "return +(a.b)",
      "return +(a[1])",
      "return +f()",
      "return +(f())",
    ]
  ) {
    let err: any = null;
    try {
      parse(src);
    } catch (e: any) {
      err = e;
    }
    assertEquals(err !== null, true, `expected parse error for: ${src}`);
    assertEquals(
      String(err?.message ?? err).includes("unexpected symbol near '+'"),
      true,
      `expected unary-plus message for: ${src}`,
    );
  }
});

Deno.test("Parser rejects unary plus - whitespace/newlines", () => {
  for (
    const src of [
      "return + 1",
      "return +\n1",
      "return +\t(1)",
      "return \n+\n(1)",
    ]
  ) {
    let err: any = null;
    try {
      parse(src);
    } catch (e: any) {
      err = e;
    }
    assertEquals(err !== null, true, `expected parse error for: ${src}`);
    assertEquals(
      String(err?.message ?? err).includes("unexpected symbol near '+'"),
      true,
      `expected unary-plus message for: ${src}`,
    );
  }
});

Deno.test("Comparison metamethods: __lt", async () => {
  const env = new LuaEnv(luaBuildStandardEnv());

  await evalBlock(
    `
      local mt = {
        __lt = function(a, b) return a.v < b.v end
      }
      local a = setmetatable({ v = 1 }, mt)
      local b = setmetatable({ v = 2 }, mt)
      res = (a < b)
    `,
    env,
  );

  assertEquals(env.get("res"), true);
});

Deno.test("Comparison metamethods: __le does not fallback to __lt", async () => {
  const env = new LuaEnv(luaBuildStandardEnv());

  let threw = false;
  try {
    await evalBlock(
      `
      local mt = {
        __lt = function(a, b) return a.v < b.v end
      }
      local a = setmetatable({ v = 2 }, mt)
      local b = setmetatable({ v = 2 }, mt)
      res = (a <= b)
    `,
      env,
    );
  } catch (e: any) {
    threw = true;
    const msg = String(e?.message ?? e);
    if (!msg.includes("attempt to compare")) {
      throw e;
    }
  }

  assertEquals(threw, true);
});

Deno.test("Equality metamethod: __eq requires same function", async () => {
  const env = new LuaEnv(luaBuildStandardEnv());

  await evalBlock(
    `
      local f1 = function(a, b) return true end
      local f2 = function(a, b) return true end
      local mt1 = { __eq = f1 }
      local mt2 = { __eq = f2 } -- different function object
      local a = setmetatable({}, mt1)
      local b = setmetatable({}, mt2)
      res = (a == b)
    `,
    env,
  );

  // Lua calls __eq even when the functions differ
  assertEquals(env.get("res"), true);
});

Deno.test("Statement evaluation", async () => {
  const env = new LuaEnv();
  env.set("test", new LuaNativeJSFunction((n) => n));
  env.set("asyncTest", new LuaNativeJSFunction((n) => Promise.resolve(n)));

  assertEquals(undefined, await evalBlock(`a = 3`, env));
  assertEquals(env.get("a"), 3);
  assertEquals(undefined, await evalBlock(`b = test(3)`, env));
  assertEquals(env.get("b"), 3);

  await evalBlock(`c = asyncTest(3)`, env);
  assertEquals(env.get("c"), 3);

  // Multiple assignments
  const env2 = new LuaEnv();
  assertEquals(undefined, await evalBlock(`a, b = 1, 2`, env2));
  assertEquals(env2.get("a"), 1);
  assertEquals(env2.get("b"), 2);

  // Other lvalues
  const env3 = new LuaEnv();
  await evalBlock(`tbl = {1, 2, 3}`, env3);
  await evalBlock(`tbl[1] = 3`, env3);
  assertEquals(luaValueToJS(env3.get("tbl"), sf), [3, 2, 3]);
  await evalBlock("tbl.name = 'Zef'", env3);
  assertEquals(env3.get("tbl").get("name"), "Zef");
  await evalBlock(`tbl[2] = {age=10}`, env3);
  await evalBlock(`tbl[2].age = 20`, env3);
  assertEquals(env3.get("tbl").get(2).get("age"), 20);

  // Blocks and scopes
  const env4 = new LuaEnv();
  env4.set("print", new LuaNativeJSFunction(console.log));
  await evalBlock(
    `
    a = 1
    do
        -- sets global a to 3
        a = 3
        print("The number is: " .. a)
    end`,
    env4,
  );
  assertEquals(env4.get("a"), 3);

  const env5 = new LuaEnv();
  env5.set("print", new LuaNativeJSFunction(console.log));

  await evalBlock(
    `
    a = 1
    if a > 0 then
        a = 3
    else
        a = 0
    end`,
    env5,
  );
  assertEquals(env5.get("a"), 3);

  await evalBlock(
    `
    if a < 0 then
        a = -1
    elseif a > 0 then
        a = 1
    else
        a = 0
    end`,
    env5,
  );
  assertEquals(env5.get("a"), 1);

  await evalBlock(
    `
        var = 1
        do
            local var
            var = 2
        end`,
    env5,
  );
  assertEquals(env5.get("var"), 1);

  // While loop
  const env6 = new LuaEnv();
  await evalBlock(
    `
        c = 0
        while true do
            c = c + 1
            if c == 3 then
                break
            end
        end
    `,
    env6,
  );
  assertEquals(env6.get("c"), 3);

  // Repeat loop
  const env7 = new LuaEnv();
  await evalBlock(
    `
        c = 0
        repeat
            c = c + 1
            if c == 3 then
                break
            end
        until false
    `,
    env7,
  );
  assertEquals(env7.get("c"), 3);

  // Function definition and calling
  const env8 = new LuaEnv();
  env8.set("print", new LuaNativeJSFunction(console.log));
  await evalBlock(
    `
        function test(a)
            return a + 1
        end
        print("3 + 1 = " .. test(3))
    `,
    env8,
  );

  // Local fucntion definition
  const env9 = new LuaEnv();
  env9.set("print", new LuaNativeJSFunction(console.log));
  await evalBlock(
    `
        local function test(a)
            return a + 1
        end
        print("3 + 1 = " .. test(3))
    `,
    env9,
  );

  // For loop over range
  const env10 = new LuaEnv();
  await evalBlock(
    `
        c = 0
        for i = 1, 3 do
            c = c + i
        end
    `,
    env10,
  );
  assertEquals(env10.get("c"), 6);

  // For loop over iterator
  const env11 = new LuaEnv(luaBuildStandardEnv());
  await evalBlock(
    `
      function fruits()
        local list = { "apple", "banana", "cherry" }
        -- Track index internally
        local index = 0

        return function()
            index = index + 1
            if list[index] then
                return list[index]
            end
        end
      end

      for fruit in fruits() do
        print("Fruit: " .. fruit)
      end
    `,
    env11,
  );

  await evalBlock(
    `
    for _, f in ipairs({ "apple", "banana", "cherry" }) do
      print("Fruit: " .. f)
    end`,
    luaBuildStandardEnv(),
  );

  // Passing a Lua function as callback to a JS function
  const env12 = new LuaEnv();
  env12.set(
    "runMe",
    new LuaNativeJSFunction((fn) => {
      return fn("Lua");
    }),
  );
  assertEquals(
    "Hello from Lua",
    await evalExpr(
      `runMe(function(name) return "Hello from " .. name end)`,
      env12,
    ),
  );
});

Deno.test("Thread local _CTX", async () => {
  const env = new LuaEnv();
  const threadLocal = new LuaEnv();
  threadLocal.setLocal("threadValue", "test123");

  const sf = new LuaStackFrame(threadLocal, null);

  await evalBlock(
    `
    function test()
      return _CTX.threadValue
    end
  `,
    env,
  );

  const result = await evalExpr("test()", env, sf);
  assertEquals(singleResult(result), "test123");
});

Deno.test("Thread local _CTX - advanced cases", async () => {
  // Create environment with standard library
  const env = new LuaEnv(luaBuildStandardEnv());
  const threadLocal = new LuaEnv();

  env.setLocal("globalEnv", "GLOBAL");

  // Set up some thread local values
  threadLocal.setLocal("user", "alice");
  threadLocal.setLocal("permissions", new LuaTable());
  threadLocal.get("permissions").set("admin", true);
  threadLocal.setLocal("data", {
    id: 123,
    settings: { theme: "dark" },
  });

  const sf = new LuaStackFrame(threadLocal, null);

  // Test 1: Nested function access
  await evalBlock(
    `
    function outer()
      local function inner()
        return _CTX.user
      end
      return inner()
    end
  `,
    env,
  );
  assertEquals(await evalExpr("outer()", env, sf), "alice");

  // Test 2: Table access and modification
  await evalBlock(
    `
    function checkAdmin()
      return _CTX.permissions.admin
    end

    function revokeAdmin()
      _CTX.permissions.admin = false
      return _CTX.permissions.admin
    end
  `,
    env,
  );
  assertEquals(await evalExpr("checkAdmin()", env, sf), true);
  assertEquals(await evalExpr("revokeAdmin()", env, sf), false);
  assertEquals(threadLocal.get("permissions").get("admin"), false);

  // Test 3: Complex data structures
  await evalBlock(
    `
    function getNestedData()
      return _CTX.data.settings.theme
    end
    
    function updateTheme(newTheme)
      _CTX.data.settings.theme = newTheme
      return _CTX.data.settings.theme
    end
    `,
    env,
  );
  assertEquals(await evalExpr("getNestedData()", env, sf), "dark");
  assertEquals(await evalExpr("updateTheme('light')", env, sf), "light");

  // Test 4: Multiple thread locals
  const threadLocal2 = new LuaEnv();
  threadLocal2.setLocal("user", "bob");
  const sf2 = new LuaStackFrame(threadLocal2, null);

  await evalBlock(
    `
    function getUser()
      return _CTX.user
    end
  `,
    env,
  );

  // Same function, different thread contexts
  assertEquals(await evalExpr("getUser()", env, sf), "alice");
  assertEquals(await evalExpr("getUser()", env, sf2), "bob");

  // Test 5: Async operations with _CTX
  env.set(
    "asyncOperation",
    new LuaNativeJSFunction(async () => {
      await new Promise((resolve) => setTimeout(resolve, 10));
      return "done";
    }),
  );

  await evalBlock(
    `
    function asyncTest()
      _CTX.status = "starting"
      local result = asyncOperation()
      _CTX.status = "completed"
      return _CTX.status
    end
  `,
    env,
  );

  assertEquals(await evalExpr("asyncTest()", env, sf), "completed");
  assertEquals(threadLocal.get("status"), "completed");

  // Test 6: Error handling with _CTX
  await evalBlock(
    `
    function errorTest()
      _CTX.error = nil
      local status, err = pcall(function()
        error("test error")
      end)
      _CTX.error = "caught"
      return _CTX.error
    end
  `,
    env,
  );

  assertEquals(await evalExpr("errorTest()", env, sf), "caught");
  assertEquals(threadLocal.get("error"), "caught");

  // Test string interpolation
  sf.threadLocal.setLocal("_GLOBAL", env);
  assertEquals(
    await evalExpr(
      "spacelua.interpolate('Hello, ${globalEnv} and ${loc}!', {loc='local'})",
      env,
      sf,
    ),
    "Hello, GLOBAL and local!",
  );

  // Some more complex string interpolation with more complex lua expressions, with nested {}
  assertEquals(
    await evalExpr(
      `spacelua.interpolate('Some JSON \${js.stringify(js.tojs({name="Pete"}))}!')`,
      env,
      sf,
    ),
    `Some JSON {"name":"Pete"}!`,
  );
});

Deno.test("Length: rawlen ignores __len", async () => {
  const env = new LuaEnv(luaBuildStandardEnv());

  await evalBlock(
    `
      local t = {1,2,3}
      setmetatable(t, { __len = function() return 99 end })
      a = #t
      b = rawlen(t)
    `,
    env,
  );

  assertEquals(env.get("a"), 99);
  assertEquals(env.get("b"), 3);
});