Feature: systematic chunks recovery

core/network/impl/peer_manager_impl.cpp

@@ -50,7 +50,7 @@ namespace {
       std::shared_ptr<kagome::network::StreamEngine> &stream_engine,
       const std::shared_ptr<P> &protocol,
       const kagome::network::PeerManager::PeerInfo &peer_info,
-      F &&func) {
+      F &&func) {  // NOLINT(cppcoreguidelines-missing-std-forward)
     BOOST_ASSERT(stream_engine);
     BOOST_ASSERT(protocol);
 

core/network/impl/protocols/protocol_req_pov.cpp

@@ -24,15 +24,15 @@ namespace kagome::network {
                        const blockchain::GenesisBlockHash &genesis_hash,
                        std::shared_ptr<ReqPovObserver> observer)
         : RequestResponseProtocolImpl<
-            RequestPov,
-            ResponsePov,
-            ScaleMessageReadWriter>{kReqPovProtocolName,
-                                    host,
-                                    make_protocols(kReqPovProtocol,
-                                                   genesis_hash,
-                                                   kProtocolPrefixPolkadot),
-                                    log::createLogger(kReqPovProtocolName,
-                                                      "req_pov_protocol")},
+              RequestPov,
+              ResponsePov,
+              ScaleMessageReadWriter>{kReqPovProtocolName,
+                                      host,
+                                      make_protocols(kReqPovProtocol,
+                                                     genesis_hash,
+                                                     kProtocolPrefixPolkadot),
+                                      log::createLogger(kReqPovProtocolName,
+                                                        "req_pov_protocol")},
           observer_{std::move(observer)} {}
 
    protected:
@@ -72,7 +72,7 @@ namespace kagome::network {
       const blockchain::GenesisBlockHash &genesis_hash,
       std::shared_ptr<ReqPovObserver> observer)
       : impl_{std::make_shared<ReqPovProtocolImpl>(
-          host, chain_spec, genesis_hash, std::move(observer))} {}
+            host, chain_spec, genesis_hash, std::move(observer))} {}
 
   const Protocol &ReqPovProtocol::protocolName() const {
     BOOST_ASSERT(impl_ && !!"ReqPovProtocolImpl must be initialized!");
@@ -99,8 +99,7 @@ namespace kagome::network {
       RequestPov request,
       std::function<void(outcome::result<ResponsePov>)> &&response_handler) {
     BOOST_ASSERT(impl_ && !!"ReqPovProtocolImpl must be initialized!");
-    return impl_->doRequest(
-        peer_id, std::move(request), std::move(response_handler));
+    return impl_->doRequest(peer_id, request, std::move(response_handler));
   }
 
 }  // namespace kagome::network

core/parachain/availability/recovery/recovery_impl.cpp

@@ -31,15 +31,16 @@ namespace {
 
   const std::array<std::string, 3> results = {"success", "failure", "invalid"};
 
+  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
 #define incFullRecoveriesFinished(strategy, result)                          \
-  do {                                                                       \
+  [&] {                                                                      \
     BOOST_ASSERT_MSG(                                                        \
         std::ranges::find(strategy_types, strategy) != strategy_types.end(), \
         "Unknown strategy type");                                            \
     BOOST_ASSERT_MSG(std::ranges::find(results, result) != results.end(),    \
                      "Unknown result type");                                 \
     full_recoveries_finished_.at(strategy).at(result)->inc();                \
-  } while (false)
+  }()
 
 }  // namespace