fix more warnings

CMakeLists.txt

@@ -30,9 +30,7 @@ target_compile_options(${PROJECT_NAME}
         -Wno-c++98-compat
         -Wno-c++98-compat-pedantic
         -Wno-covered-switch-default
-        -Wno-ctad-maybe-unsupported
         -Wno-exit-time-destructors
-        -Wno-float-equal
         -Wno-global-constructors
         -Wno-padded
         -Wno-shadow-field-in-constructor

headers/meta.hpp/meta_base/enum_bitflags.hpp

@@ -133,7 +133,7 @@ namespace enum_hpp::bitflags
         }\
         template < typename Enum >\
         constexpr bitflags<Enum> operator op (bitflags<Enum> l, Enum r) noexcept {\
-            return l op bitflags{r};\
+            return l op bitflags<Enum>{r};\
         }\
         template < typename Enum >\
         constexpr bitflags<Enum> operator op (bitflags<Enum> l, bitflags<Enum> r) noexcept {\
@@ -141,7 +141,7 @@ namespace enum_hpp::bitflags
         }\
         template < typename Enum >\
         constexpr bitflags<Enum>& operator op##= (bitflags<Enum>& l, Enum r) noexcept {\
-            return l = l op bitflags{r};\
+            return l = l op bitflags<Enum>{r};\
         }\
         template < typename Enum >\
         constexpr bitflags<Enum>& operator op##= (bitflags<Enum>& l, bitflags<Enum> r) noexcept {\
@@ -319,14 +319,14 @@ namespace enum_hpp::bitflags
 
 #define ENUM_HPP_OPERATORS_DECL(Enum)\
     constexpr ::enum_hpp::bitflags::bitflags<Enum> operator~ [[maybe_unused]] (Enum l) noexcept {\
-        return ~::enum_hpp::bitflags::bitflags(l);\
+        return ~::enum_hpp::bitflags::bitflags<Enum>(l);\
     }\
     constexpr ::enum_hpp::bitflags::bitflags<Enum> operator| [[maybe_unused]] (Enum l, Enum r) noexcept {\
-        return ::enum_hpp::bitflags::bitflags(l) | ::enum_hpp::bitflags::bitflags(r);\
+        return ::enum_hpp::bitflags::bitflags<Enum>(l) | ::enum_hpp::bitflags::bitflags<Enum>(r);\
     }\
     constexpr ::enum_hpp::bitflags::bitflags<Enum> operator& [[maybe_unused]] (Enum l, Enum r) noexcept {\
-        return ::enum_hpp::bitflags::bitflags(l) & ::enum_hpp::bitflags::bitflags(r);\
+        return ::enum_hpp::bitflags::bitflags<Enum>(l) & ::enum_hpp::bitflags::bitflags<Enum>(r);\
     }\
     constexpr ::enum_hpp::bitflags::bitflags<Enum> operator^ [[maybe_unused]] (Enum l, Enum r) noexcept {\
-        return ::enum_hpp::bitflags::bitflags(l) ^ ::enum_hpp::bitflags::bitflags(r);\
+        return ::enum_hpp::bitflags::bitflags<Enum>(l) ^ ::enum_hpp::bitflags::bitflags<Enum>(r);\
     }

headers/meta.hpp/meta_detail/value_traits/equals_traits.hpp

@@ -24,11 +24,11 @@ namespace meta_hpp::detail
 {
     template < typename T >
         requires requires(const T& l, const T& r) {
-            { l == r } -> stdex::convertible_to<bool>;
+            { std::equal_to<>{}(l, r) } -> stdex::convertible_to<bool>;
         }
     struct equals_traits<T> {
         bool operator()(const T& l, const T& r) const {
-            return l == r;
+            return std::equal_to<>{}(l, r);
         }
     };
 }

headers/meta.hpp/meta_detail/value_traits/less_traits.hpp

@@ -24,11 +24,11 @@ namespace meta_hpp::detail
 {
     template < typename T >
         requires requires(const T& l, const T& r) {
-            { l < r } -> stdex::convertible_to<bool>;
+            { std::less<>{}(l, r) } -> stdex::convertible_to<bool>;
         }
     struct less_traits<T> {
         bool operator()(const T& l, const T& r) const {
-            return l < r;
+            return std::less<>{}(l, r);
         }
     };
 }

headers/meta.hpp/meta_indices/evalue_index.hpp

@@ -32,10 +32,10 @@ namespace meta_hpp
     }
 
     inline bool operator<(const evalue_index& l, const evalue_index& r) noexcept {
-        return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_);
+        return l.type_ < r.type_ || (l.type_ == r.type_ && std::less<>{}(l.name_, r.name_));
     }
 
     inline bool operator==(const evalue_index& l, const evalue_index& r) noexcept {
-        return l.type_ == r.type_ && l.name_ == r.name_;
+        return l.type_ == r.type_ && std::equal_to<>{}(l.name_, r.name_);
     }
 }

headers/meta.hpp/meta_indices/function_index.hpp

@@ -32,10 +32,10 @@ namespace meta_hpp
     }
 
     inline bool operator<(const function_index& l, const function_index& r) noexcept {
-        return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_);
+        return l.type_ < r.type_ || (l.type_ == r.type_ && std::less<>{}(l.name_, r.name_));
     }
 
     inline bool operator==(const function_index& l, const function_index& r) noexcept {
-        return l.type_ == r.type_ && l.name_ == r.name_;
+        return l.type_ == r.type_ && std::equal_to<>{}(l.name_, r.name_);
     }
 }

headers/meta.hpp/meta_indices/member_index.hpp

@@ -32,10 +32,10 @@ namespace meta_hpp
     }
 
     inline bool operator<(const member_index& l, const member_index& r) noexcept {
-        return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_);
+        return l.type_ < r.type_ || (l.type_ == r.type_ && std::less<>{}(l.name_, r.name_));
     }
 
     inline bool operator==(const member_index& l, const member_index& r) noexcept {
-        return l.type_ == r.type_ && l.name_ == r.name_;
+        return l.type_ == r.type_ && std::equal_to<>{}(l.name_, r.name_);
     }
 }

headers/meta.hpp/meta_indices/method_index.hpp

@@ -32,10 +32,10 @@ namespace meta_hpp
     }
 
     inline bool operator<(const method_index& l, const method_index& r) noexcept {
-        return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_);
+        return l.type_ < r.type_ || (l.type_ == r.type_ && std::less<>{}(l.name_, r.name_));
     }
 
     inline bool operator==(const method_index& l, const method_index& r) noexcept {
-        return l.type_ == r.type_ && l.name_ == r.name_;
+        return l.type_ == r.type_ && std::equal_to<>{}(l.name_, r.name_);
     }
 }

headers/meta.hpp/meta_indices/scope_index.hpp

@@ -26,10 +26,10 @@ namespace meta_hpp
     }
 
     inline bool operator<(const scope_index& l, const scope_index& r) noexcept {
-        return l.name_ < r.name_;
+        return std::less<>{}(l.name_, r.name_);
     }
 
     inline bool operator==(const scope_index& l, const scope_index& r) noexcept {
-        return l.name_ == r.name_;
+        return std::equal_to<>{}(l.name_, r.name_);
     }
 }

headers/meta.hpp/meta_indices/variable_index.hpp

@@ -32,10 +32,10 @@ namespace meta_hpp
     }
 
     inline bool operator<(const variable_index& l, const variable_index& r) noexcept {
-        return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_);
+        return l.type_ < r.type_ || (l.type_ == r.type_ && std::less<>{}(l.name_, r.name_));
     }
 
     inline bool operator==(const variable_index& l, const variable_index& r) noexcept {
-        return l.type_ == r.type_ && l.name_ == r.name_;
+        return l.type_ == r.type_ && std::equal_to<>{}(l.name_, r.name_);
     }
 }