Support comparison of heterogenous values

Fixes #94.

Author: SquidDev

src/main/java/org/squiddev/cobalt/OperationHelper.java

@@ -215,54 +215,46 @@ public static LuaValue concatNonStrings(LuaState state, LuaValue left, LuaValue
 	//endregion
 
 	//region Compare
+	private static LuaValue getComparisonMetatable(LuaState state, LuaValue tag, LuaValue left, LuaValue right) throws LuaError {
+		LuaValue h = left.metatag(state, tag);
+		if (!h.isNil()) return h;
+
+		return right.metatag(state, tag);
+	}
+
 	public static boolean lt(LuaState state, LuaValue left, LuaValue right) throws LuaError, UnwindThrowable {
-		int tLeft = left.type();
-		if (tLeft != right.type()) {
-			throw ErrorFactory.compareError(left, right);
-		}
-		switch (tLeft) {
-			case TNUMBER:
-				return left.toDouble() < right.toDouble();
-			case TSTRING:
-				return left.checkLuaString().compareTo(right.checkLuaString()) < 0;
-			default:
-				LuaValue h = left.metatag(state, Constants.LT);
-				if (!h.isNil() && h == right.metatag(state, Constants.LT)) {
-					return Dispatch.call(state, h, left, right).toBoolean();
-				} else {
-					throw ErrorFactory.compareError(left, right);
-				}
-		}
+		int tLeft = left.type(), tRight = right.type();
+
+		if (tLeft == TNUMBER && tRight == TNUMBER) return left.toDouble() < right.toDouble();
+		if (tLeft == TSTRING && tRight == TSTRING) return left.checkLuaString().compareTo(right.checkLuaString()) < 0;
+
+		var mt = getComparisonMetatable(state, LT, left, right);
+		if (mt.isNil()) throw ErrorFactory.compareError(left, right);
+
+		return Dispatch.call(state, mt, left, right).toBoolean();
 	}
 
 	public static boolean le(LuaState state, LuaValue left, LuaValue right) throws LuaError, UnwindThrowable {
-		int tLeft = left.type();
-		if (tLeft != right.type()) {
-			throw ErrorFactory.compareError(left, right);
+		int tLeft = left.type(), tRight = right.type();
+
+		if (tLeft == TNUMBER && tRight == TNUMBER) return left.toDouble() <= right.toDouble();
+		if (tLeft == TSTRING && tRight == TSTRING) return left.checkLuaString().compareTo(right.checkLuaString()) <= 0;
+
+		{ // Prefer __le.
+			var leMt = getComparisonMetatable(state, LE, left, right);
+			if (!leMt.isNil()) return Dispatch.call(state, leMt, left, right).toBoolean();
 		}
-		switch (tLeft) {
-			case TNUMBER:
-				return left.toDouble() <= right.toDouble();
-			case TSTRING:
-				return left.checkLuaString().compareTo(right.checkLuaString()) <= 0;
-			default:
-				LuaValue h = left.metatag(state, Constants.LE);
-				if (h.isNil()) {
-					h = left.metatag(state, Constants.LT);
-					if (!h.isNil() && h == right.metatag(state, Constants.LT)) {
-						DebugFrame frame = DebugState.get(state).getStackUnsafe();
-
-						frame.flags |= FLAG_LEQ;
-						boolean result = !Dispatch.call(state, h, right, left).toBoolean();
-						frame.flags ^= FLAG_LEQ;
-
-						return result;
-					}
-				} else if (h == right.metatag(state, Constants.LE)) {
-					return Dispatch.call(state, h, left, right).toBoolean();
-				}
 
-				throw ErrorFactory.compareError(left, right);
+		{ // If unavailable, fall back to __lt.
+			var ltMt = getComparisonMetatable(state, LT, left, right);
+			if (ltMt.isNil()) throw ErrorFactory.compareError(left, right);
+			DebugFrame frame = DebugState.get(state).getStackUnsafe();
+
+			frame.flags |= FLAG_LEQ;
+			boolean result = !Dispatch.call(state, ltMt, right, left).toBoolean();
+			frame.flags ^= FLAG_LEQ;
+
+			return result;
 		}
 	}
 

src/test/resources/spec/operation_spec.lua

@@ -40,4 +40,61 @@ describe("Lua's base operators", function()
 			expect.error(adder, "hello"):strip_context():eq("attempt to add a 'number' with a 'string'")
 		end)
 	end)
+
+	describe("comparison", function()
+		local function value(x) if type(x) == "number" then return x else return x.value end end
+		local comparable_mt = {
+			__lt = function(x, y) return value(x) < value(y) end,
+			__le = function(x, y) return value(x) <= value(y) end,
+		}
+
+		local function mk(x) return setmetatable({ value = x }, comparable_mt) end
+
+		it("compare homogenous values", function()
+			expect(mk(1) < mk(2)):eq(true)
+			expect(mk(2) < mk(2)):eq(false)
+			expect(mk(3) < mk(2)):eq(false)
+
+			expect(mk(1) <= mk(2)):eq(true)
+			expect(mk(2) <= mk(2)):eq(true)
+			expect(mk(3) <= mk(2)):eq(false)
+		end)
+
+		it("cannot compare heterogenous values :lua<=5.1 :!cobalt", function()
+			expect.error(function() return mk(1) < 2 end)
+				:str_match(": attempt to compare table with number$")
+		end)
+
+		it("cannot compare heterogenous values", function()
+			expect.error(function() return "2.0" < 2 end)
+				:str_match(": attempt to compare string with number$")
+		end)
+
+		it("compare heterogenous values :lua>=5.2", function()
+			expect(mk(1) < 2):eq(true)
+			expect(mk(2) < 2):eq(false)
+			expect(mk(3) < 2):eq(false)
+
+			expect(1 < mk(2)):eq(true)
+			expect(2 < mk(2)):eq(false)
+			expect(3 < mk(2)):eq(false)
+
+			expect(mk(1) <= 2):eq(true)
+			expect(mk(2) <= 2):eq(true)
+			expect(mk(3) <= 2):eq(false)
+
+			expect(1 <= mk(2)):eq(true)
+			expect(2 <= mk(2)):eq(true)
+			expect(3 <= mk(2)):eq(false)
+		end)
+
+		it("<= falls back to __lt", function()
+			local comparable_mt = { __lt = function(x, y) return value(x) < value(y) end }
+			local function mk(x) return setmetatable({ value = x }, comparable_mt) end
+
+			expect(mk(1) <= mk(2)):eq(true)
+			expect(mk(2) <= mk(2)):eq(true)
+			expect(mk(3) <= mk(2)):eq(false)
+		end)
+	end)
 end)