fix: Literals not implementing strict weak ordering correctly (#188)

* Not working. Committed before I stuff shit up further.

* Undo lunacy

* Note to self

* This is actually starting to find issues

* Fix sort bug (ImHex, not checker)

* Move variant type index code into header

* DRY

* Tidy up

* Make sort checks optional

* tidy up

* Put checks in other container types

* Disable sort checks

* Make enable macro cover more code

* Remove namespace qual

* disable sort checks

* Add static_assert. Fiddle around

* Remove sort check code

* Remove formatting change

* Adjust codeing style

* More style changes

Author: shewitt-au

lib/include/pl/core/token.hpp

@@ -220,8 +220,10 @@ namespace pl::core {
             constexpr bool operator==(const Comment &) const = default;
         };
 
+        using LiteralVariantType = std::variant<char, bool, u128, i128, double, std::string, std::shared_ptr<ptrn::Pattern>>;
 
-        struct Literal : std::variant<char, bool, u128, i128, double, std::string, std::shared_ptr<ptrn::Pattern>> {
+
+        struct Literal : LiteralVariantType {
             using variant::variant;
 
             [[nodiscard]] std::shared_ptr<ptrn::Pattern> toPattern() const;

lib/include/pl/helpers/variant_type_index.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <variant>
+#include <type_traits>
+#include <cstddef>
+
+namespace pl::hlp {
+
+template<typename T, typename Variant>
+struct VariantTypeIndexImpl;
+
+template<typename T, typename... Ts>
+struct VariantTypeIndexImpl<T, std::variant<Ts...>> {
+    static constexpr auto value = [] -> std::size_t {
+        static_assert(
+            (std::is_same_v<std::remove_cvref_t<T>, Ts> || ...),
+            "T not in std::variant");
+        constexpr bool matches[] = { std::is_same_v<std::remove_cvref_t<T>, Ts>... };
+
+        for (std::size_t i=0; i<sizeof...(Ts); ++i) {
+            if (matches[i]) { return i; }
+        }
+
+        return -1;
+    }();
+};
+
+template<class T, class Variant>
+inline constexpr std::size_t VariantTypeIndex = VariantTypeIndexImpl<T, Variant>::value;
+
+} // namespace pl::hlp

lib/source/pl/core/token.cpp

@@ -5,6 +5,7 @@
 
 #include <pl/helpers/utils.hpp>
 #include <pl/helpers/concepts.hpp>
+#include <pl/helpers/variant_type_index.hpp>
 #include <variant>
 
 namespace pl::core {
@@ -160,8 +161,8 @@ namespace pl::core {
                     return std::strong_ordering::greater;
                 }
             },
-            [](auto, auto) -> std::strong_ordering {
-                return std::strong_ordering::equal;
+            []<typename TL, typename TR>(TL, TR) -> std::strong_ordering {
+                return hlp::VariantTypeIndex<TL, LiteralVariantType> <=> hlp::VariantTypeIndex<TR, LiteralVariantType>;
             }
         }, *this, other);
     }