refactor: small cleanups around variable shadowing and scope

src/dwarfs/block_cache.cpp

@@ -609,7 +609,7 @@ class block_cache_ final : public block_cache::impl {
 
     // Check if another worker is already processing this block
     {
-      std::lock_guard lock(mx_dec_);
+      std::lock_guard lock_dec(mx_dec_);
 
       auto di = decompressing_.find(block_no);
 

src/dwarfs/categorizer.cpp

@@ -282,8 +282,8 @@ fragment_category categorizer_manager::default_category() {
 
 template <typename LoggerPolicy>
 void categorizer_manager_<LoggerPolicy>::add(std::shared_ptr<categorizer> c) {
-  for (auto const& c : c->categories()) {
+  for (auto const& cat : c->categories()) {
-    add_category(c, categorizers_.size());
+    add_category(cat, categorizers_.size());
   }
 
   categorizers_.emplace_back(std::move(c));

src/dwarfs/inode_reader_v2.cpp

@@ -195,9 +195,8 @@ void inode_reader_<LoggerPolicy>::do_readahead(uint32_t inode,
     std::lock_guard lock(readahead_cache_mutex_);
 
     if (read_offset > 0) {
-      if (auto it = readahead_cache_.find(inode);
+      if (auto i = readahead_cache_.find(inode); i != readahead_cache_.end()) {
-          it != readahead_cache_.end()) {
+        readahead_pos = i->second;
-        readahead_pos = it->second;
       }
 
       if (readahead_until <= readahead_pos) {

src/dwarfs/scanner.cpp

@@ -491,10 +491,10 @@ scanner_<LoggerPolicy>::scan_tree(std::filesystem::path const& path,
     DWARFS_CHECK(parent, "expected directory");
 
     queue.pop_front();
-    auto path = parent->fs_path();
+    auto ppath = parent->fs_path();
 
     try {
-      auto d = os_->opendir(path);
+      auto d = os_->opendir(ppath);
       std::filesystem::path name;
       std::vector<std::shared_ptr<entry>> subdirs;
 
@@ -510,7 +510,7 @@ scanner_<LoggerPolicy>::scan_tree(std::filesystem::path const& path,
 
       prog.dirs_scanned++;
     } catch (const std::system_error& e) {
-      LOG_ERROR << "cannot read directory `" << path
+      LOG_ERROR << "cannot read directory `" << ppath
                 << "`: " << folly::exceptionStr(e);
       prog.errors++;
     }

src/dwarfs/util.cpp

@@ -272,9 +272,7 @@ void utf8_sanitize(std::string& str) {
 }
 
 void shorten_path_string(std::string& path, char separator, size_t max_len) {
-  auto len = utf8_display_width(path);
+  if (utf8_display_width(path) > max_len) {
-
-  if (len > max_len) {
     if (max_len < 3) {
       path.clear();
       return;
@@ -293,7 +291,7 @@ void shorten_path_string(std::string& path, char separator, size_t max_len) {
 
     path.replace(0, start, "...");
 
-    if (auto len = utf8_display_width(path); len > max_len) {
+    if (utf8_display_width(path) > max_len) {
       if (max_len >= 7) {
         utf8_truncate(path, max_len - 3);
         path += "...";

src/mkdwarfs_main.cpp

@@ -49,6 +49,7 @@
 #include <folly/Conv.h>
 #include <folly/FileUtil.h>
 #include <folly/String.h>
+#include <folly/container/Enumerate.h>
 #include <folly/gen/String.h>
 #include <folly/portability/SysStat.h>
 #include <folly/system/HardwareConcurrency.h>
@@ -334,8 +335,8 @@ class categorize_optval {
   void add_implicit_defaults(T& cop) const {
     if (is_implicit_default()) {
       if (auto it = defaults_.find(cop.name()); it != defaults_.end()) {
-        for (auto const& value : it->second) {
+        for (auto const& v : it->second) {
-          cop.parse_fallback(value);
+          cop.parse_fallback(v);
         }
       }
     }
@@ -713,16 +714,14 @@ int mkdwarfs_main(int argc, sys_char** argv, iolayer const& iol) {
                            metadata_hdr, l_mc, "Size/Step  Order")
             << "  " << sep << "\n";
 
-    int level = 0;
+    for (auto const& [i, l] : folly::enumerate(levels)) {
-    for (auto const& l : levels) {
       iol.out << fmt::format("  {:1d}      {:2d}     {:{}s}  {:{}s}  {:{}s}"
                              "  {:2d} / {:1d}    {:{}s}",
-                             level, l.block_size_bits, l.data_compression, l_dc,
+                             i, l.block_size_bits, l.data_compression, l_dc,
                              l.schema_history_compression, l_sc,
                              l.metadata_compression, l_mc, l.window_size,
                              l.window_step, l.order, l_or)
               << "\n";
-      ++level;
     }
 
     iol.out << "  " << sep << "\n";

test/block_cache_test.cpp

@@ -138,7 +138,6 @@ TEST_P(options_test, cache_stress) {
 
   auto const& cache_opts = GetParam();
 
-  std::mt19937_64 rng{42};
   auto os = std::make_shared<test::os_access_mock>();
 
   {
@@ -222,6 +221,7 @@ TEST_P(options_test, cache_stress) {
   };
 
   std::vector<std::vector<read_request>> data(num_threads);
+  std::mt19937_64 rng{42};
 
   for (auto& reqs : data) {
     while (reqs.size() < num_read_reqs) {