fix(math): resolve strict weak ordering violations in comparison operators

Author: floppyhammer

pathfinder/common/color.h

@@ -97,6 +97,14 @@ struct ColorU {
 
     ColorU lerp(const ColorU& other, float t) const;
 
+    bool operator==(const ColorU& rhs) const {
+        return to_u32() == rhs.to_u32();
+    }
+
+    bool operator!=(const ColorU& rhs) const {
+        return to_u32() != rhs.to_u32();
+    }
+
     bool operator<(const ColorU& rhs) const {
         return to_u32() < rhs.to_u32();
     }

pathfinder/common/math/mat2.h

@@ -79,7 +79,7 @@ struct Mat2 {
 
     // For being used as ordered key.
     bool operator<(const Mat2 &b) const {
-        return v[0] < b.v[0] && v[1] < b.v[1] && v[2] < b.v[2] && v[3] < b.v[3];
+        return std::tie(v[0], v[1], v[2], v[3]) < std::tie(b.v[0], b.v[1], b.v[2], b.v[3]);
     }
 
     Vec2F operator*(const Vec2F &other) const {

pathfinder/common/math/transform2.h

@@ -101,7 +101,15 @@ struct Transform2 {
 
     // For being used as ordered key.
     bool operator<(const Transform2 &rhs) const {
-        return matrix < rhs.matrix && vector < rhs.vector;
+        return std::tie(matrix, vector) < std::tie(rhs.matrix, rhs.vector);
+    }
+
+    bool operator==(const Transform2 &rhs) const {
+        return matrix == rhs.matrix && vector == rhs.vector;
+    }
+
+    bool operator!=(const Transform2 &rhs) const {
+        return !(*this == rhs);
     }
 };
 

pathfinder/common/math/vec2.h

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <cmath>
 #include <sstream>
+#include <tuple>
 
 #include "../logger.h"
 
@@ -133,13 +134,13 @@ struct Vec2 {
         return x == b.x && y == b.y;
     }
 
-    // For being used as ordered key.
-    bool operator<(const Vec2 &b) const {
-        return x < b.x && y < b.y;
+    bool operator!=(const Vec2 &b) const {
+        return !(*this == b);
     }
 
-    bool operator!=(const Vec2 &b) const {
-        return x != b.x || y != b.y;
+    // For being used as ordered key.
+    bool operator<(const Vec2 &b) const {
+        return std::tie(x, y) < std::tie(b.x, b.y);
     }
 
     void operator+=(const Vec2 &b) {

pathfinder/core/data/line_segment.h

@@ -102,11 +102,17 @@ struct LineSegmentF {
 
     // For being used as ordered key.
     bool operator<(const LineSegmentF &rhs) const {
-        bool res = value.get<0>() < rhs.value.get<0>();
-        res = res && value.get<1>() < rhs.value.get<1>();
-        res = res && value.get<2>() < rhs.value.get<2>();
-        res = res && value.get<3>() < rhs.value.get<3>();
-        return res;
+        return std::forward_as_tuple(value.get<0>(), value.get<1>(), value.get<2>(), value.get<3>()) <
+               std::forward_as_tuple(rhs.value.get<0>(), rhs.value.get<1>(), rhs.value.get<2>(), rhs.value.get<3>());
+    }
+
+    bool operator==(const LineSegmentF &rhs) const {
+        return std::forward_as_tuple(value.get<0>(), value.get<1>(), value.get<2>(), value.get<3>()) ==
+               std::forward_as_tuple(rhs.value.get<0>(), rhs.value.get<1>(), rhs.value.get<2>(), rhs.value.get<3>());
+    }
+
+    bool operator!=(const LineSegmentF &rhs) const {
+        return !(*this == rhs);
     }
 };
 

pathfinder/core/paint/gradient.h

@@ -20,6 +20,21 @@ struct ColorStop {
 
     /// The color of the gradient stop.
     ColorU color;
+
+    bool operator<(const ColorStop &rhs) const {
+        if (offset != rhs.offset) {
+            return offset < rhs.offset;
+        }
+        return color < rhs.color;
+    }
+
+    bool operator==(const ColorStop &rhs) const {
+        return offset == rhs.offset && color == rhs.color;
+    }
+
+    bool operator!=(const ColorStop &rhs) const {
+        return !(*this == rhs);
+    }
 };
 
 struct GradientRadial {
@@ -130,22 +145,38 @@ class Gradient {
 
     // For being used as ordered key.
     bool operator<(const Gradient &rhs) const {
-        if (wrap == rhs.wrap) {
-            if (geometry.type == rhs.geometry.type) {
-                if (geometry.type == GradientGeometry::Type::Linear) {
-                    return geometry.linear < rhs.geometry.linear;
-                } else {
-                    bool res = geometry.radial.line < rhs.geometry.radial.line;
-                    res = res && geometry.radial.radii < rhs.geometry.radial.radii;
-                    res = res && geometry.radial.transform < rhs.geometry.radial.transform;
-                    return res;
-                }
-            } else {
-                return geometry.type < rhs.geometry.type;
-            }
-        } else {
+        // 1. Compare the outer wrap mode first.
+        if (wrap != rhs.wrap) {
             return wrap < rhs.wrap;
         }
+
+        // 2. Compare the gradient geometry type.
+        if (geometry.type != rhs.geometry.type) {
+            return geometry.type < rhs.geometry.type;
+        }
+
+        // 3. Branch based on the type and perform strict lexicographical comparison.
+        if (geometry.type == GradientGeometry::Type::Linear) {
+            // Standard total-ordering chain for linear gradient.
+            if (geometry.linear < rhs.geometry.linear) return true;
+            if (rhs.geometry.linear < geometry.linear) return false;
+        } else { // Radial
+            // CRITICAL FIX: Replaced the incorrect '&&' logic with lexicographical comparison
+            // using std::forward_as_tuple to maintain Strict Weak Ordering for rvalues/lvalues.
+            auto tuple_lhs =
+                std::forward_as_tuple(geometry.radial.line, geometry.radial.radii, geometry.radial.transform);
+            auto tuple_rhs = std::forward_as_tuple(rhs.geometry.radial.line,
+                                                   rhs.geometry.radial.radii,
+                                                   rhs.geometry.radial.transform);
+            if (tuple_lhs != tuple_rhs) {
+                return tuple_lhs < tuple_rhs;
+            }
+        }
+
+        // 4. CRITICAL FIX: Compare the 'stops' vector (color stops).
+        // If all geometry attributes are identical, gradients with different colors must not be treated as equivalent.
+        // std::vector's operator< automatically performs a sequential lexicographical comparison on its elements.
+        return stops < rhs.stops;
     }
 
 private: