Merge pull request #379 from nuskey8/codex/pr-lua52-vm-semantics

fix: align Lua 5.2 VM equality, modulo and loop rules

Author: akeit0

src/Lua/LuaValue.cs

@@ -769,8 +769,9 @@ CancellationToken cancellationToken
                 var count = await LuaVirtualMachine.Call(state, top, top, cancellationToken);
                 var result = count > 0 ? stack.Get(top) : Nil;
                 stack.SetTop(top + 1);
-                // Return one value, padding missing results and discarding extras.
-                stack.FastGet(top) = result;
+                // Lua 5.2 converts a numeric __tostring result to text.
+                stack.FastGet(top) =
+                    result.Type == LuaValueType.Number ? new LuaValue(result.ToString()) : result;
                 return 1;
             }
             catch

src/Lua/Runtime/LuaVirtualMachine.cs

@@ -810,6 +810,21 @@ out doRestart
                             continue;
                         }
 
+                        // Lua 5.2 only invokes __eq for tables/userdata of the
+                        // same type. Primitive inequality needs no slow-path call.
+                        if (
+                            vb.Type != vc.Type
+                            || vb.Type is not (LuaValueType.Table or LuaValueType.UserData)
+                        )
+                        {
+                            if (iA == 1)
+                            {
+                                context.Pc++;
+                            }
+
+                            continue;
+                        }
+
                         if (
                             ExecuteCompareOperationMetaMethod(
                                 vb,
@@ -950,7 +965,7 @@ out doRestart
                         var step = Unsafe.Add(ref indexRef, 2).UnsafeReadDouble();
                         var index = indexRef.UnsafeReadDouble() + step;
 
-                        if (step >= 0 ? index <= limit : limit <= index)
+                        if (step > 0 ? index <= limit : limit <= index)
                         {
                             context.Pc += instruction.SBx;
                             indexRef = index;
@@ -1128,13 +1143,9 @@ OpCode opcode
     [MethodImpl(MethodImplOptions.NoInlining)]
     internal static double Mod(double a, double b)
     {
-        var mod = a % b;
-        if ((b > 0 && mod < 0) || (b < 0 && mod > 0))
-        {
-            mod += b;
-        }
-
-        return mod;
+        // Lua 5.2 uses this expression, including its floating-point rounding.
+        // A sign-adjusted remainder differs for values such as 5 and 0.1.
+        return a - (Math.Floor(a / b) * b);
     }
 
     static void SelfPostOperation(
@@ -2810,6 +2821,32 @@ CancellationToken cancellationToken
         }
     }
 
+    static bool TryGetCompareMetamethod(
+        LuaGlobalState state,
+        LuaValue left,
+        LuaValue right,
+        string name,
+        out LuaValue metamethod
+    )
+    {
+        if (name == Metamethods.Eq)
+        {
+            metamethod = default;
+            return left.Type == right.Type
+                && left.Type is LuaValueType.Table or LuaValueType.UserData
+                && state.TryGetMetatable(left, out var leftMetatable)
+                && leftMetatable.TryGetValue(name, out metamethod)
+                && state.TryGetMetatable(right, out var rightMetatable)
+                && (
+                    leftMetatable == rightMetatable
+                    || rightMetatable.TryGetValue(name, out var other) && metamethod == other
+                );
+        }
+
+        return left.TryGetMetamethod(state, name, out metamethod)
+            || right.TryGetMetamethod(state, name, out metamethod);
+    }
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     static bool ExecuteCompareOperationMetaMethod(
         LuaValue vb,
@@ -2823,10 +2860,7 @@ out bool doRestart
         doRestart = false;
         var reverseLe = false;
         ReCheck:
-        if (
-            vb.TryGetMetamethod(context.GlobalState, name, out var metamethod)
-            || vc.TryGetMetamethod(context.GlobalState, name, out metamethod)
-        )
+        if (TryGetCompareMetamethod(context.GlobalState, vb, vc, name, out var metamethod))
         {
             var stack = context.Stack;
             var newBase = stack.Count;
@@ -2959,10 +2993,7 @@ CancellationToken cancellationToken
         var (name, description) = opCode.GetNameAndDescription();
         var reverseLe = false;
         ReCheck:
-        if (
-            vb.TryGetMetamethod(state.GlobalState, name, out var metamethod)
-            || vc.TryGetMetamethod(state.GlobalState, name, out metamethod)
-        )
+        if (TryGetCompareMetamethod(state.GlobalState, vb, vc, name, out var metamethod))
         {
             var stack = state.Stack;
             var top = stack.Count;

tests/Lua.Tests/ArithmeticExecutionRegressionTests.cs

@@ -85,4 +85,21 @@ public async Task ArithmeticBytecodeRoundTripAndSpecialNumbers()
         var results = await state.ExecuteAsync(restored);
         Assert.That(results[0].Read<double>(), Is.EqualTo(8));
     }
+
+    [Test]
+    public async Task ZeroStepNumericForUsesLua52Direction()
+    {
+        using var state = CreateState();
+        await state.DoStringAsync(
+            """
+            local count = 0
+            for i = 1, 2, 0 do count = count + 1; break end
+            assert(count == 0)
+            for i = 2, 1, 0 do count = count + 1; break end
+            assert(count == 1)
+            for i = 1, 1, -0.0 do count = count + 1; break end
+            assert(count == 2)
+            """
+        );
+    }
 }

tests/Lua.Tests/CompilerTests.cs

@@ -126,4 +126,16 @@ public async Task SyntaxDepthFailureRestoresCounter()
         }
         Assert.That((await state.DoStringAsync("return 42"))[0].Read<double>(), Is.EqualTo(42));
     }
+
+    [TestCase("5", "0.1")]
+    [TestCase("1e308", "3")]
+    [TestCase("-5", "0.1")]
+    [TestCase("5", "-0.1")]
+    public async Task FoldedAndRuntimeModuloUseLua52Formula(string a, string b)
+    {
+        using var state = CreateState();
+        var results = await state.DoStringAsync($"local a,b={a},{b}; return {a}%{b},a%b");
+        Assert.That(results[0].Read<double>(), Is.Zero);
+        Assert.That(results[1].Read<double>(), Is.Zero);
+    }
 }

tests/Lua.Tests/NativeCallbackResultTests.cs

@@ -203,4 +203,30 @@ public async Task ManagedCallbacksDistinguishNoResultsFromNil(
         Assert.That(state.Stack.Pop().Read<double>(), Is.EqualTo(12345));
         Assert.That(state.CallStackFrameCount, Is.Zero);
     }
+
+    [Test]
+    public async Task ToStringUsesOneStringResult([Values] bool hooks, [Values] bool suspend)
+    {
+        using var state = CreateState();
+        state.Environment["format"] = new LuaFunction(
+            async (context, token) =>
+            {
+                if (suspend)
+                    await Task.Yield();
+                return context.Return(12, "extra");
+            }
+        );
+        if (hooks)
+            await state.DoStringAsync("debug.sethook(function() end,'cr')");
+        await state.DoStringAsync(
+            """
+            local x=setmetatable({}, {__tostring=format})
+            assert(select('#',tostring(x))==1)
+            assert(tostring(x)=='12')
+            assert(string.format('%s:%s',x,'tail')=='12:tail')
+            """
+        );
+        Assert.That(state.Stack.Count, Is.Zero);
+        Assert.That(state.CallStackFrameCount, Is.Zero);
+    }
 }

tests/Lua.Tests/VirtualMachineExecutionTests.cs

@@ -282,4 +282,42 @@ await state.DoStringAsync(
         Assert.That(state.Stack.Pop().Read<double>(), Is.EqualTo(12345));
         Assert.That(state.CallStackFrameCount, Is.Zero);
     }
+
+    [Test]
+    public async Task EqualityRequiresMatchingTypesAndSharedMetamethod()
+    {
+        using var state = CreateState();
+        await state.DoStringAsync(
+            """
+            local calls = 0
+            local function eq(a,b) calls=calls+1; return true end
+            local a = setmetatable({}, {__eq=eq})
+            local b = {}
+            assert(not (a == b) and not (b == a) and calls == 0)
+            setmetatable(b, {__eq=function() return true end})
+            assert(not (a == b) and calls == 0)
+            setmetatable(b, {__eq=eq})
+            assert(a == b and calls == 1)
+            assert(a == a and calls == 1)
+            assert(not (a == 1) and not (1 == a) and calls == 1)
+            debug.setmetatable(1, {__eq=function() error('numeric __eq must not run') end})
+            local x,y = 1,2
+            assert(x ~= y)
+            debug.setmetatable(1, nil)
+            -- A shared metatable selects even a non-reflexive NaN tag method.
+            -- Calling it must fail; separate metatables do not share that value.
+            local nan=0/0
+            local mt={__eq=nan}
+            setmetatable(a, mt); setmetatable(b, mt)
+            assert(not pcall(function() return a == b end))
+            setmetatable(b, {__eq=nan})
+            assert(not (a == b))
+            """
+        );
+        var a = state.Environment["a"] = new LuaTable();
+        var b = state.Environment["b"] = new LuaTable();
+        await state.DoStringAsync("setmetatable(a, {__eq=function() return true end})");
+        Assert.That(await state.EqualsAsync(a, b), Is.False);
+        Assert.That(await state.EqualsAsync(b, a), Is.False);
+    }
 }