clang-tidy: Fix misc-const-correctness check

hebasto · ryanofsky · hebasto · commit 848c902dd0cd · 2025-02-05T03:42:45.000Z
See: https://clang.llvm.org/extra/clang-tidy/checks/misc/const-correctness.html Co-authored-by: Ryan Ofsky <ryan@ofsky.org>
diff --git a/example/calculator.cpp b/example/calculator.cpp
@@ -43,7 +43,7 @@ int main(int argc, char** argv)
         return 1;
     }
     mp::EventLoop loop("mpcalculator", LogPrint);
-    int fd = std::stoi(argv[1]);
+    const int fd = std::stoi(argv[1]);
     std::unique_ptr<Init> init = std::make_unique<InitImpl>();
     mp::ServeStream<InitInterface>(loop, fd, *init);
     loop.loop();
diff --git a/example/example.cpp b/example/example.cpp
@@ -14,7 +14,7 @@ namespace fs = std::filesystem;
 auto Spawn(mp::EventLoop& loop, const std::string& process_argv0, const std::string& new_exe_name)
 {
     int pid;
-    int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {
+    const int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {
         fs::path path = process_argv0;
         path.remove_filename();
         path.append(new_exe_name);
diff --git a/example/printer.cpp b/example/printer.cpp
@@ -37,7 +37,7 @@ int main(int argc, char** argv)
         return 1;
     }
     mp::EventLoop loop("mpprinter", LogPrint);
-    int fd = std::stoi(argv[1]);
+    const int fd = std::stoi(argv[1]);
     std::unique_ptr<Init> init = std::make_unique<InitImpl>();
     mp::ServeStream<InitInterface>(loop, fd, *init);
     loop.loop();
diff --git a/include/mp/proxy-io.h b/include/mp/proxy-io.h
@@ -247,7 +247,7 @@ struct Waiter
     template <typename Fn>
     void post(Fn&& fn)
     {
-        std::unique_lock<std::mutex> lock(m_mutex);
+        const std::unique_lock<std::mutex> lock(m_mutex);
         assert(!m_fn);
         m_fn = std::move(fn);
         m_cv.notify_all();
@@ -269,7 +269,7 @@ struct Waiter
                 fn();
                 lock.lock();
             }
-            bool done = pred();
+            const bool done = pred();
             return done;
         });
     }
diff --git a/include/mp/proxy-types.h b/include/mp/proxy-types.h
@@ -626,15 +626,15 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
                 } catch (...) {
                     exception = std::current_exception();
                 }
-                std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
+                const std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
                 done = true;
                 invoke_context.thread_context.waiter->m_cv.notify_all();
             },
             [&](const ::kj::Exception& e) {
                 kj_exception = kj::str("kj::Exception: ", e).cStr();
                 proxy_client.m_context.connection->m_loop.logPlain()
                     << "{" << invoke_context.thread_context.thread_name << "} IPC client exception " << kj_exception;
-                std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
+                const std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
                 done = true;
                 invoke_context.thread_context.waiter->m_cv.notify_all();
             }));
diff --git a/include/mp/util.h b/include/mp/util.h
@@ -142,7 +142,7 @@ struct UnlockGuard
 template <typename Lock, typename Callback>
 void Unlock(Lock& lock, Callback&& callback)
 {
-    UnlockGuard<Lock> unlock(lock);
+    const UnlockGuard<Lock> unlock(lock);
     callback();
 }
 
diff --git a/src/mp/gen.cpp b/src/mp/gen.cpp
@@ -151,7 +151,7 @@ void Generate(kj::StringPtr src_prefix,
     }
 
     std::string include_base = include_path;
-    std::string::size_type p = include_base.rfind('.');
+    const std::string::size_type p = include_base.rfind('.');
     if (p != std::string::npos) include_base.erase(p);
 
     std::vector<std::string> args;
@@ -165,19 +165,19 @@ void Generate(kj::StringPtr src_prefix,
     }
     args.emplace_back("--output=" capnp_PREFIX "/bin/capnpc-c++");
     args.emplace_back(src_file);
-    int pid = fork();
+    const int pid = fork();
     if (pid == -1) {
         throw std::system_error(errno, std::system_category(), "fork");
     }
     if (!pid) {
         mp::ExecProcess(args);
     }
-    int status = mp::WaitProcess(pid);
+    const int status = mp::WaitProcess(pid);
     if (status) {
         throw std::runtime_error("Invoking " capnp_PREFIX "/bin/capnp failed");
     }
 
-    capnp::SchemaParser parser;
+    const capnp::SchemaParser parser;
     auto directory_pointers = kj::heapArray<const kj::ReadableDirectory*>(import_dirs.size());
     for (size_t i = 0; i < import_dirs.size(); ++i) {
         directory_pointers[i] = import_dirs[i].get();
@@ -244,7 +244,7 @@ void Generate(kj::StringPtr src_prefix,
     GetAnnotationText(file_schema.getProto(), NAMESPACE_ANNOTATION_ID, &message_namespace);
 
     std::string base_name = include_base;
-    size_t output_slash = base_name.rfind('/');
+    const size_t output_slash = base_name.rfind('/');
     if (output_slash != std::string::npos) {
         base_name.erase(0, output_slash + 1);
     }
@@ -260,7 +260,7 @@ void Generate(kj::StringPtr src_prefix,
 
     auto add_accessor = [&](kj::StringPtr name) {
         if (!accessors_done.insert(name).second) return;
-        std::string cap = Cap(name);
+        const std::string cap = Cap(name);
         accessors << "struct " << cap << "\n";
         accessors << "{\n";
         accessors << "    template<typename S> static auto get(S&& s) -> decltype(s.get" << cap << "()) { return s.get" << cap << "(); }\n";
@@ -368,19 +368,19 @@ void Generate(kj::StringPtr src_prefix,
             server << "    using ProxyServerCustom::ProxyServerCustom;\n";
             server << "    ~ProxyServer();\n";
 
-            std::ostringstream client_construct;
-            std::ostringstream client_destroy;
+            const std::ostringstream client_construct;
+            const std::ostringstream client_destroy;
 
             int method_ordinal = 0;
             ForEachMethod(interface, [&] (const capnp::InterfaceSchema& method_interface, const capnp::InterfaceSchema::Method& method) {
-                kj::StringPtr method_name = method.getProto().getName();
+                const kj::StringPtr method_name = method.getProto().getName();
                 kj::StringPtr proxied_method_name = method_name;
                 GetAnnotationText(method.getProto(), NAME_ANNOTATION_ID, &proxied_method_name);
 
                 const std::string method_prefix = Format() << message_namespace << "::" << method_interface.getShortDisplayName()
                                                            << "::" << Cap(method_name);
-                bool is_construct = method_name == "construct";
-                bool is_destroy = method_name == "destroy";
+                const bool is_construct = method_name == "construct";
+                const bool is_destroy = method_name == "destroy";
 
                 struct Field
                 {
@@ -530,9 +530,9 @@ void Generate(kj::StringPtr src_prefix,
                     server_invoke_end << ")";
                 }
 
-                std::string static_str{is_construct || is_destroy ? "static " : ""};
-                std::string super_str{is_construct || is_destroy ? "Super& super" : ""};
-                std::string self_str{is_construct || is_destroy ? "super" : "*this"};
+                const std::string static_str{is_construct || is_destroy ? "static " : ""};
+                const std::string super_str{is_construct || is_destroy ? "Super& super" : ""};
+                const std::string self_str{is_construct || is_destroy ? "super" : "*this"};
 
                 client << "    using M" << method_ordinal << " = ProxyClientMethodTraits<" << method_prefix
                        << "Params>;\n";
diff --git a/src/mp/proxy.cpp b/src/mp/proxy.cpp
@@ -102,7 +102,7 @@ Connection::~Connection()
         m_sync_cleanup_fns.pop_front();
     }
     while (!m_async_cleanup_fns.empty()) {
-        std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+        const std::unique_lock<std::mutex> lock(m_loop.m_mutex);
         m_loop.m_async_fns.emplace_back(std::move(m_async_cleanup_fns.front()));
         m_async_cleanup_fns.pop_front();
     }
@@ -113,7 +113,7 @@ Connection::~Connection()
 
 CleanupIt Connection::addSyncCleanup(std::function<void()> fn)
 {
-    std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+    const std::unique_lock<std::mutex> lock(m_loop.m_mutex);
     // Add cleanup callbacks to the front of list, so sync cleanup functions run
     // in LIFO order. This is a good approach because sync cleanup functions are
     // added as client objects are created, and it is natural to clean up
@@ -127,13 +127,13 @@ CleanupIt Connection::addSyncCleanup(std::function<void()> fn)
 
 void Connection::removeSyncCleanup(CleanupIt it)
 {
-    std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+    const std::unique_lock<std::mutex> lock(m_loop.m_mutex);
     m_sync_cleanup_fns.erase(it);
 }
 
 void Connection::addAsyncCleanup(std::function<void()> fn)
 {
-    std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+    const std::unique_lock<std::mutex> lock(m_loop.m_mutex);
     // Add async cleanup callbacks to the back of the list. Unlike the sync
     // cleanup list, this list order is more significant because it determines
     // the order server objects are destroyed when there is a sudden disconnect,
@@ -169,7 +169,7 @@ EventLoop::EventLoop(const char* exe_name, LogFn log_fn, void* context)
 EventLoop::~EventLoop()
 {
     if (m_async_thread.joinable()) m_async_thread.join();
-    std::lock_guard<std::mutex> lock(m_mutex);
+    const std::lock_guard<std::mutex> lock(m_mutex);
     KJ_ASSERT(m_post_fn == nullptr);
     KJ_ASSERT(m_async_fns.empty());
     KJ_ASSERT(m_wait_fd == -1);
@@ -192,7 +192,7 @@ void EventLoop::loop()
     int post_fd{m_post_fd};
     char buffer = 0;
     for (;;) {
-        size_t read_bytes = wait_stream->read(&buffer, 0, 1).wait(m_io_context.waitScope);
+        const size_t read_bytes = wait_stream->read(&buffer, 0, 1).wait(m_io_context.waitScope);
         if (read_bytes != 1) throw std::logic_error("EventLoop wait_stream closed unexpectedly");
         std::unique_lock<std::mutex> lock(m_mutex);
         if (m_post_fn) {
@@ -212,7 +212,7 @@ void EventLoop::loop()
     log() << "EventLoop::loop bye.";
     wait_stream = nullptr;
     KJ_SYSCALL(::close(post_fd));
-    std::unique_lock<std::mutex> lock(m_mutex);
+    const std::unique_lock<std::mutex> lock(m_mutex);
     m_wait_fd = -1;
     m_post_fd = -1;
 }
@@ -258,7 +258,7 @@ void EventLoop::startAsyncThread(std::unique_lock<std::mutex>& lock)
             while (true) {
                 if (!m_async_fns.empty()) {
                     addClient(lock);
-                    std::function<void()> fn = std::move(m_async_fns.front());
+                    const std::function<void()> fn = std::move(m_async_fns.front());
                     m_async_fns.pop_front();
                     Unlock(lock, fn);
                     removeClient(lock);
@@ -282,7 +282,7 @@ bool EventLoop::done(std::unique_lock<std::mutex>& lock)
 
 std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex, Connection* connection, std::function<Thread::Client()> make_thread)
 {
-    std::unique_lock<std::mutex> lock(mutex);
+    const std::unique_lock<std::mutex> lock(mutex);
     auto thread = threads.find(connection);
     if (thread != threads.end()) return {thread, false};
     thread = threads.emplace(
@@ -299,7 +299,7 @@ std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex,
         // try unregister this callback after connection is destroyed.
         thread->second.m_cleanup_it.reset();
         // Remove connection pointer about to be destroyed from the map
-        std::unique_lock<std::mutex> lock(mutex);
+        const std::unique_lock<std::mutex> lock(mutex);
         threads.erase(thread);
     });
     return {thread, true};
@@ -339,7 +339,7 @@ ProxyServer<Thread>::~ProxyServer()
     assert(m_thread_context.waiter.get());
     std::unique_ptr<Waiter> waiter;
     {
-        std::unique_lock<std::mutex> lock(m_thread_context.waiter->m_mutex);
+        const std::unique_lock<std::mutex> lock(m_thread_context.waiter->m_mutex);
         //! Reset thread context waiter pointer, as shutdown signal for done
         //! lambda passed as waiter->wait() argument in makeThread code below.
         waiter = std::move(m_thread_context.waiter);
@@ -367,7 +367,7 @@ ProxyServer<ThreadMap>::ProxyServer(Connection& connection) : m_connection(conne
 
 kj::Promise<void> ProxyServer<ThreadMap>::makeThread(MakeThreadContext context)
 {
-    std::string from = context.getParams().getName();
+    const std::string from = context.getParams().getName();
     std::promise<ThreadContext*> thread_context;
     std::thread thread([&thread_context, from, this]() {
         g_thread_context.thread_name = ThreadName(m_connection.m_loop.m_exe_name) + " (from " + from + ")";
diff --git a/src/mp/util.cpp b/src/mp/util.cpp
@@ -80,7 +80,7 @@ std::string LogEscape(const kj::StringTree& string)
     std::string result;
     string.visit([&](const kj::ArrayPtr<const char>& piece) {
         if (result.size() > MAX_SIZE) return;
-        for (char c : piece) {
+        for (const char c : piece) {
             if (c == '\\') {
                 result.append("\\\\");
             } else if (c < 0x20 || c > 0x7e) {
@@ -116,7 +116,7 @@ int SpawnProcess(int& pid, FdToArgsFn&& fd_to_args)
     }
     if (!pid) {
         // Child process must close all potentially open descriptors, except socket 0.
-        int maxFd = MaxFd();
+        const int maxFd = MaxFd();
         for (int fd = 3; fd < maxFd; ++fd) {
             if (fd != fds[0]) {
                 close(fd);

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ int main(int argc, char** argv)`
`43`	`43`	`return 1;`
`44`	`44`	`}`
`45`	`45`	`mp::EventLoop loop("mpcalculator", LogPrint);`
`46`		`- int fd = std::stoi(argv[1]);`
	`46`	`+ const int fd = std::stoi(argv[1]);`
`47`	`47`	`std::unique_ptr<Init> init = std::make_unique<InitImpl>();`
`48`	`48`	`mp::ServeStream<InitInterface>(loop, fd, *init);`
`49`	`49`	`loop.loop();`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace fs = std::filesystem;`
`14`	`14`	`auto Spawn(mp::EventLoop& loop, const std::string& process_argv0, const std::string& new_exe_name)`
`15`	`15`	`{`
`16`	`16`	`int pid;`
`17`		`- int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {`
	`17`	`+ const int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {`
`18`	`18`	`fs::path path = process_argv0;`
`19`	`19`	`path.remove_filename();`
`20`	`20`	`path.append(new_exe_name);`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ int main(int argc, char** argv)`
`37`	`37`	`return 1;`
`38`	`38`	`}`
`39`	`39`	`mp::EventLoop loop("mpprinter", LogPrint);`
`40`		`- int fd = std::stoi(argv[1]);`
	`40`	`+ const int fd = std::stoi(argv[1]);`
`41`	`41`	`std::unique_ptr<Init> init = std::make_unique<InitImpl>();`
`42`	`42`	`mp::ServeStream<InitInterface>(loop, fd, *init);`
`43`	`43`	`loop.loop();`
Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ struct Waiter`
`247`	`247`	`template <typename Fn>`
`248`	`248`	`void post(Fn&& fn)`
`249`	`249`	`{`
`250`		`- std::unique_lock<std::mutex> lock(m_mutex);`
	`250`	`+ const std::unique_lock<std::mutex> lock(m_mutex);`
`251`	`251`	`assert(!m_fn);`
`252`	`252`	`m_fn = std::move(fn);`
`253`	`253`	`m_cv.notify_all();`
`@@ -269,7 +269,7 @@ struct Waiter`
`269`	`269`	`fn();`
`270`	`270`	`lock.lock();`
`271`	`271`	`}`
`272`		`- bool done = pred();`
	`272`	`+ const bool done = pred();`
`273`	`273`	`return done;`
`274`	`274`	`});`
`275`	`275`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ struct UnlockGuard`
`142`	`142`	`template <typename Lock, typename Callback>`
`143`	`143`	`void Unlock(Lock& lock, Callback&& callback)`
`144`	`144`	`{`
`145`		`- UnlockGuard<Lock> unlock(lock);`
	`145`	`+ const UnlockGuard<Lock> unlock(lock);`
`146`	`146`	`callback();`
`147`	`147`	`}`
`148`	`148`