Revert "Moar clang-tidy warnings"

This reverts commit 305211c.

silkworm/sentry/discovery/discovery.cpp

@@ -139,10 +139,8 @@ Task<std::vector<Discovery::PeerCandidate>> DiscoveryImpl::request_peer_candidat
     using namespace std::chrono_literals;
 
     std::vector<node_db::NodeId> exclude_ids;
-    exclude_ids.reserve(exclude_urls.size());
-    for (auto& url : exclude_urls) {
+    for (auto& url : exclude_urls)
         exclude_ids.push_back(url.public_key());
-    }
 
     auto now = std::chrono::system_clock::now();
     node_db::NodeDb::FindPeerCandidatesQuery query{

silkworm/sentry/grpc/interfaces/peer_info.hpp

@@ -25,12 +25,12 @@
 namespace silkworm::sentry::grpc::interfaces {
 
 api::PeerInfo peer_info_from_proto_peer_info(const types::PeerInfo& info);
-types::PeerInfo proto_peer_info_from_peer_info(const api::PeerInfo&);
+types::PeerInfo proto_peer_info_from_peer_info(const api::PeerInfo& info);
 
 api::PeerInfos peer_infos_from_proto_peers_reply(const ::sentry::PeersReply& reply);
-::sentry::PeersReply proto_peers_reply_from_peer_infos(const api::PeerInfos&);
+::sentry::PeersReply proto_peers_reply_from_peer_infos(const api::PeerInfos& infos);
 
 std::optional<api::PeerInfo> peer_info_opt_from_proto_peer_reply(const ::sentry::PeerByIdReply& reply);
-::sentry::PeerByIdReply proto_peer_reply_from_peer_info_opt(const std::optional<api::PeerInfo>&);
+::sentry::PeerByIdReply proto_peer_reply_from_peer_info_opt(const std::optional<api::PeerInfo>& info_opt);
 
 }  // namespace silkworm::sentry::grpc::interfaces

silkworm/sentry/multi_sentry_client.cpp

@@ -50,13 +50,13 @@ class MultiSentryClientImpl : public api::Service {
         std::function<Task<void>(std::shared_ptr<api::Service>)> callback) {
         using namespace concurrency::awaitable_wait_for_one;
 
-        auto call_factory = [&clients, &callback](size_t index) -> Task<void> {
+        std::function<Task<void>(size_t)> call_factory = [&clients, &callback](size_t index) -> Task<void> {
             auto client = clients[index];
             auto service = co_await client->service();
             co_await callback(service);
         };
 
-        auto group_task = concurrency::generate_parallel_group_task(clients.size(), call_factory);
+        auto group_task = concurrency::generate_parallel_group_task(clients.size(), std::move(call_factory));
 
         try {
             co_await (std::move(group_task) || concurrency::timeout(timeout));

silkworm/sentry/peer_manager.cpp

@@ -139,14 +139,14 @@ Task<size_t> PeerManager::count_peers_in_strand() {
 
 Task<void> PeerManager::enumerate_peers_in_strand(EnumeratePeersCallback callback) {
     for (auto& peer : peers_) {
-        callback(*peer);
+        callback(peer);
     }
     co_return;
 }
 
 Task<void> PeerManager::enumerate_random_peers_in_strand(size_t max_count, EnumeratePeersCallback callback) {
     for (auto peer_ptr : random_list_items(peers_, max_count)) {
-        callback(**peer_ptr);
+        callback(*peer_ptr);
     }
     co_return;
 }

silkworm/sentry/peer_manager.hpp

@@ -66,7 +66,7 @@ class PeerManager {
         std::unique_ptr<rlpx::Protocol> protocol,
         std::function<std::unique_ptr<rlpx::Client>()> client_factory);
 
-    using EnumeratePeersCallback = std::function<void(rlpx::Peer&)>;
+    using EnumeratePeersCallback = std::function<void(std::shared_ptr<rlpx::Peer>)>;
 
     Task<size_t> count_peers();
     Task<void> enumerate_peers(EnumeratePeersCallback callback);

silkworm/sentry/peer_manager_api.cpp

@@ -91,8 +91,8 @@ Task<void> PeerManagerApi::handle_peers_calls() {
         auto call = co_await peers_calls_channel_.receive();
 
         api::PeerInfos peers;
-        co_await peer_manager_.enumerate_peers([&peers](rlpx::Peer& peer) {
-            auto info_opt = make_peer_info(peer);
+        co_await peer_manager_.enumerate_peers([&peers](std::shared_ptr<rlpx::Peer> peer) {
+            auto info_opt = make_peer_info(*peer);
             if (info_opt) {
                 peers.push_back(info_opt.value());
             }
@@ -109,10 +109,10 @@ Task<void> PeerManagerApi::handle_peer_calls() {
         auto peer_public_key_opt = call.peer_public_key;
 
         std::optional<api::PeerInfo> info_opt;
-        co_await peer_manager_.enumerate_peers([&info_opt, &peer_public_key_opt](rlpx::Peer& peer) {
-            auto key_opt = peer.peer_public_key();
+        co_await peer_manager_.enumerate_peers([&info_opt, &peer_public_key_opt](std::shared_ptr<rlpx::Peer> peer) {
+            auto key_opt = peer->peer_public_key();
             if (key_opt && peer_public_key_opt && (key_opt.value() == peer_public_key_opt.value())) {
-                info_opt = make_peer_info(peer);
+                info_opt = make_peer_info(*peer);
             }
         });
 
@@ -125,10 +125,10 @@ Task<void> PeerManagerApi::handle_peer_penalize_calls() {
     while (true) {
         auto peer_public_key_opt = co_await peer_penalize_calls_channel_.receive();
 
-        co_await peer_manager_.enumerate_peers([&peer_public_key_opt](rlpx::Peer& peer) {
-            auto key_opt = peer.peer_public_key();
+        co_await peer_manager_.enumerate_peers([&peer_public_key_opt](std::shared_ptr<rlpx::Peer> peer) {
+            auto key_opt = peer->peer_public_key();
             if (key_opt && peer_public_key_opt && (key_opt.value() == peer_public_key_opt.value())) {
-                peer.disconnect(rlpx::DisconnectReason::DisconnectRequested);
+                peer->disconnect(rlpx::DisconnectReason::DisconnectRequested);
             }
         });
     }