Merge #165: clang-tidy: fix warnings introduced in version 19

aa19285 use ranges transform (Daniel Pfeifer)
a78137c make member function const (Daniel Pfeifer)
ca3226e replace custom tuple unpacking code with `std::apply` (Daniel Pfeifer)
949fe85 replace SFINAE trick with `if constexpr` (Daniel Pfeifer)

Pull request description:

  Should fix #153.

ACKs for top commit:
  ryanofsky:
    Code review ACK aa19285

Tree-SHA512: 21e87f82c02a6e59569f2da61e8c8716719af29fa94d43549eae86b7b41ce1f37c5782a9f42f38ef58bdc1a5adbb0bc2c5b5a41a07dc8c8e06c573e92f7d1155

Author: ryanofsky

include/mp/proxy-io.h

@@ -172,7 +172,7 @@ class EventLoop
     void addClient(std::unique_lock<std::mutex>& lock);
     bool removeClient(std::unique_lock<std::mutex>& lock);
     //! Check if loop should exit.
-    bool done(std::unique_lock<std::mutex>& lock);
+    bool done(std::unique_lock<std::mutex>& lock) const;
 
     Logger log()
     {

include/mp/proxy-types.h

@@ -37,20 +37,45 @@ struct StructField
     }
     Struct& m_struct;
 
-    // clang-format off
-    template<typename A = Accessor> auto get() const -> decltype(A::get(this->m_struct)) { return A::get(this->m_struct); }
-    template<typename A = Accessor> auto has() const -> std::enable_if_t<A::optional, bool> { return A::getHas(m_struct); }
-    template<typename A = Accessor> auto has() const -> std::enable_if_t<!A::optional && A::boxed, bool> { return A::has(m_struct); }
-    template<typename A = Accessor> auto has() const -> std::enable_if_t<!A::optional && !A::boxed, bool> { return true; }
-    template<typename A = Accessor> auto want() const -> std::enable_if_t<A::requested, bool> { return A::getWant(m_struct); }
-    template<typename A = Accessor> auto want() const -> std::enable_if_t<!A::requested, bool> { return true; }
-    template<typename A = Accessor, typename... Args> decltype(auto) set(Args&&... args) const { return A::set(this->m_struct, std::forward<Args>(args)...); }
-    template<typename A = Accessor, typename... Args> decltype(auto) init(Args&&... args) const { return A::init(this->m_struct, std::forward<Args>(args)...); }
-    template<typename A = Accessor> auto setHas() const -> std::enable_if_t<A::optional> { return A::setHas(m_struct); }
-    template<typename A = Accessor> auto setHas() const -> std::enable_if_t<!A::optional> { }
-    template<typename A = Accessor> auto setWant() const -> std::enable_if_t<A::requested> { return A::setWant(m_struct); }
-    template<typename A = Accessor> auto setWant() const -> std::enable_if_t<!A::requested> { }
-    // clang-format on
+    decltype(auto) get() const { return Accessor::get(this->m_struct); }
+
+    bool has() const {
+      if constexpr (Accessor::optional) {
+        return Accessor::getHas(m_struct);
+      } else if constexpr (Accessor::boxed) {
+        return Accessor::has(m_struct);
+      } else {
+        return true;
+      }
+    }
+
+    bool want() const {
+      if constexpr (Accessor::requested) {
+        return Accessor::getWant(m_struct);
+      } else {
+        return true;
+      }
+    }
+
+    template <typename... Args> decltype(auto) set(Args &&...args) const {
+      return Accessor::set(this->m_struct, std::forward<Args>(args)...);
+    }
+
+    template <typename... Args> decltype(auto) init(Args &&...args) const {
+      return Accessor::init(this->m_struct, std::forward<Args>(args)...);
+    }
+
+    void setHas() const {
+      if constexpr (Accessor::optional) {
+        Accessor::setHas(m_struct);
+      }
+    }
+
+    void setWant() const {
+      if constexpr (Accessor::requested) {
+        Accessor::setWant(m_struct);
+      }
+    }
 };
 
 
@@ -364,30 +389,17 @@ struct ClientParam
 
     struct BuildParams : IterateFieldsHelper<BuildParams, sizeof...(Types)>
     {
-        template <typename... Args>
-        void handleField(Args&&... args)
-        {
-            callBuild<0>(std::forward<Args>(args)...);
-        }
-
-        // TODO Possible optimization to speed up compile time:
-        // https://stackoverflow.com/a/7858971 Using enable_if below to check
-        // position when unpacking tuple might be slower than pattern matching
-        // approach in the stack overflow solution
-        template <size_t I, typename... Args>
-        auto callBuild(Args&&... args) -> std::enable_if_t<(I < sizeof...(Types))>
-        {
-            callBuild<I + 1>(std::forward<Args>(args)..., std::get<I>(m_client_param->m_values));
-        }
-
-        template <size_t I, typename Params, typename ParamList, typename... Values>
-        auto callBuild(ClientInvokeContext& invoke_context, Params& params, ParamList, Values&&... values) ->
-            std::enable_if_t<(I == sizeof...(Types))>
+        template <typename Params, typename ParamList>
+        void handleField(ClientInvokeContext& invoke_context, Params& params, ParamList)
         {
-            MaybeBuildField(std::integral_constant<bool, Accessor::in>(), ParamList(), invoke_context,
-                Make<StructField, Accessor>(params), std::forward<Values>(values)...);
-            MaybeSetWant(
-                ParamList(), Priority<1>(), std::forward<Values>(values)..., Make<StructField, Accessor>(params));
+            auto const fun = [&]<typename... Values>(Values&&... values) {
+                MaybeBuildField(std::integral_constant<bool, Accessor::in>(), ParamList(), invoke_context,
+                    Make<StructField, Accessor>(params), std::forward<Values>(values)...);
+                MaybeSetWant(
+                    ParamList(), Priority<1>(), std::forward<Values>(values)..., Make<StructField, Accessor>(params));
+            };
+
+            std::apply(fun, m_client_param->m_values);
         }
 
         BuildParams(ClientParam* client_param) : m_client_param(client_param) {}
@@ -396,24 +408,15 @@ struct ClientParam
 
     struct ReadResults : IterateFieldsHelper<ReadResults, sizeof...(Types)>
     {
-        template <typename... Args>
-        void handleField(Args&&... args)
+        template <typename Results, typename... Params>
+        void handleField(ClientInvokeContext& invoke_context, Results& results, TypeList<Params...>)
         {
-            callRead<0>(std::forward<Args>(args)...);
-        }
+            auto const fun = [&]<typename... Values>(Values&&... values) {
+                MaybeReadField(std::integral_constant<bool, Accessor::out>(), TypeList<Decay<Params>...>(), invoke_context,
+                    Make<StructField, Accessor>(results), ReadDestUpdate(values)...);
+            };
 
-        template <int I, typename... Args>
-        auto callRead(Args&&... args) -> std::enable_if_t<(I < sizeof...(Types))>
-        {
-            callRead<I + 1>(std::forward<Args>(args)..., std::get<I>(m_client_param->m_values));
-        }
-
-        template <int I, typename Results, typename... Params, typename... Values>
-        auto callRead(ClientInvokeContext& invoke_context, Results& results, TypeList<Params...>, Values&&... values)
-            -> std::enable_if_t<I == sizeof...(Types)>
-        {
-            MaybeReadField(std::integral_constant<bool, Accessor::out>(), TypeList<Decay<Params>...>(), invoke_context,
-                Make<StructField, Accessor>(results), ReadDestUpdate(values)...);
+            std::apply(fun, m_client_param->m_values);
         }
 
         ReadResults(ClientParam* client_param) : m_client_param(client_param) {}
@@ -650,19 +653,14 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
 //! return value with value of `ret()`. This is useful for avoiding code
 //! duplication and branching in generic code that forwards calls to functions.
 template <typename Fn, typename Ret>
-auto ReplaceVoid(Fn&& fn, Ret&& ret) ->
-    std::enable_if_t<std::is_same_v<void, decltype(fn())>, decltype(ret())>
+auto ReplaceVoid(Fn&& fn, Ret&& ret)
 {
-    fn();
-    return ret();
-}
-
-//! Overload of above for non-void `fn()` case.
-template <typename Fn, typename Ret>
-auto ReplaceVoid(Fn&& fn, Ret&& ret) ->
-    std::enable_if_t<!std::is_same_v<void, decltype(fn())>, decltype(fn())>
-{
-    return fn();
+    if constexpr (std::is_same_v<decltype(fn()), void>) {
+        fn();
+        return ret();
+    } else {
+        return fn();
+    }
 }
 
 extern std::atomic<int> server_reqs;

src/mp/gen.cpp

@@ -215,7 +215,7 @@ static void Generate(kj::StringPtr src_prefix,
     cpp_types << "namespace mp {\n";
 
     std::string guard = output_path;
-    std::transform(guard.begin(), guard.end(), guard.begin(), [](unsigned char c) -> unsigned char {
+    std::ranges::transform(guard, guard.begin(), [](unsigned char c) -> unsigned char {
         if ('0' <= c && c <= '9') return c;
         if ('A' <= c && c <= 'Z') return c;
         if ('a' <= c && c <= 'z') return c - 'a' + 'A';

src/mp/proxy.cpp

@@ -277,7 +277,7 @@ void EventLoop::startAsyncThread(std::unique_lock<std::mutex>& lock)
     }
 }
 
-bool EventLoop::done(std::unique_lock<std::mutex>& lock)
+bool EventLoop::done(std::unique_lock<std::mutex>& lock) const
 {
     assert(m_num_clients >= 0);
     assert(lock.owns_lock());