Switch to using c++20 constraints instead of std::enable_if

.clang-tidy

@@ -66,10 +66,6 @@ Checks: [-*,
          -modernize-use-std-format,
          -modernize-use-std-numbers,
          -modernize-use-std-print,
-
-         # C++20 supports constraints but until Spicy supports building with C++20
-         # this one has to stay disabled.
-         -modernize-use-constraints,
 ]
 
 HeaderFilterRegex: '.h'

src/Event.h

@@ -129,8 +129,8 @@ public:
      * A version of Enqueue() taking a variable number of arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>> Enqueue(
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
-        const EventHandlerPtr& h, Args&&... args) {
+    void Enqueue(const EventHandlerPtr& h, Args&&... args) {
         return Enqueue(h, zeek::Args{std::forward<Args>(args)...});
     }
 

src/Func.h

@@ -104,8 +104,8 @@ public:
      * A version of Invoke() taking a variable number of individual arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>, ValPtr> Invoke(
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
-        Args&&... args) const {
+    ValPtr Invoke(Args&&... args) const {
         auto zargs = zeek::Args{std::forward<Args>(args)...};
         return Invoke(&zargs);
     }

src/IntrusivePtr.h

@@ -102,7 +102,8 @@ public:
 
     IntrusivePtr(const IntrusivePtr& other) noexcept : IntrusivePtr(NewRef{}, other.get()) {}
 
-    template<class U, class = std::enable_if_t<std::is_convertible_v<U*, T*>>>
+    template<class U>
+        requires std::is_convertible_v<U*, T*>
     IntrusivePtr(IntrusivePtr<U> other) noexcept : ptr_(other.release()) {
         // nop
     }

src/Span.h

@@ -54,12 +54,12 @@ public:
     template<size_t Size>
     constexpr Span(element_type (&arr)[Size]) noexcept : memory_block(arr), num_elements(Size) {}
 
-    template<class Container, class Data = typename Container::value_type,
+    template<class Container, class Data = typename Container::value_type>
-             class = std::enable_if_t<std::is_convertible_v<Data*, T*>>>
+        requires std::is_convertible_v<Data*, T*>
     Span(Container& xs) noexcept : memory_block(xs.data()), num_elements(xs.size()) {}
 
-    template<class Container, class Data = typename Container::value_type,
+    template<class Container, class Data = typename Container::value_type>
-             class = std::enable_if_t<std::is_convertible_v<const Data*, T*>>>
+        requires std::is_convertible_v<const Data*, T*>
     Span(const Container& xs) noexcept : memory_block(xs.data()), num_elements(xs.size()) {}
 
     constexpr Span(const Span&) noexcept = default;

src/Val.h

@@ -1328,7 +1328,8 @@ public:
     // access to record fields (without requiring an intermediary Val).
     // It is up to the caller to ensure that the field exists in the
     // record (using HasRawField(), if necessary).
-    template<typename T, typename std::enable_if_t<is_zeek_val_v<T>, bool> = true>
+    template<typename T>
+        requires is_zeek_val_v<T>
     auto GetFieldAs(int field) const -> std::invoke_result_t<decltype(&T::Get), T> {
         if constexpr ( std::is_same_v<T, BoolVal> || std::is_same_v<T, IntVal> || std::is_same_v<T, EnumVal> )
             return record_val[field]->int_val;
@@ -1365,7 +1366,8 @@ public:
         }
     }
 
-    template<typename T, typename std::enable_if_t<! is_zeek_val_v<T>, bool> = true>
+    template<typename T>
+        requires(! is_zeek_val_v<T>)
     T GetFieldAs(int field) const {
         if constexpr ( std::is_integral_v<T> && std::is_signed_v<T> )
             return record_val[field]->int_val;

src/analyzer/Analyzer.h

@@ -624,8 +624,8 @@ public:
      * A version of EnqueueConnEvent() taking a variable number of arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>> EnqueueConnEvent(
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
-        EventHandlerPtr h, Args&&... args) {
+    void EnqueueConnEvent(EventHandlerPtr h, Args&&... args) {
         return EnqueueConnEvent(h, zeek::Args{std::forward<Args>(args)...});
     }
 

src/broker/Data.h

@@ -493,7 +493,8 @@ public:
 
     BrokerData() = default;
 
-    template<class DataType, class = std::enable_if_t<std::is_same_v<DataType, broker::data>>>
+    template<class DataType>
+        requires std::is_same_v<DataType, broker::data>
     explicit BrokerData(DataType value) : value_(std::move(value)) {
         // Note: we use enable_if here to avoid nasty implicit conversions of broker::data.
     }

src/session/Session.h

@@ -130,8 +130,8 @@ public:
      * A version of EnqueueEvent() taking a variable number of arguments.
      */
     template<class... Args>
-    std::enable_if_t<std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>> EnqueueEvent(
+        requires std::is_convertible_v<std::tuple_element_t<0, std::tuple<Args...>>, ValPtr>
-        EventHandlerPtr h, analyzer::Analyzer* analyzer, Args&&... args) {
+    void EnqueueEvent(EventHandlerPtr h, analyzer::Analyzer* analyzer, Args&&... args) {
         return EnqueueEvent(h, analyzer, zeek::Args{std::forward<Args>(args)...});
     }