Apply changes suggested by clang-tidy 11

30 files changed, 248 insertions, 186 deletions

diff --git a/src/buildtool/build_engine/base_maps/rule_map.cpp b/src/buildtool/build_engine/base_maps/rule_map.cpp
index b6f56b2b..67612172 100644
--- a/src/buildtool/build_engine/base_maps/rule_map.cpp
+++ b/src/buildtool/build_engine/base_maps/rule_map.cpp
@@ -12,20 +12,20 @@ namespace BuildMaps::Base {
 
 namespace {
 
-auto rule_fields = std::unordered_set<std::string>{"anonymous",
-                                                   "config_doc",
-                                                   "config_fields",
-                                                   "config_transitions",
-                                                   "config_vars",
-                                                   "doc",
-                                                   "expression",
-                                                   "field_doc",
-                                                   "implicit",
-                                                   "imports",
-                                                   "import",
-                                                   "string_fields",
-                                                   "tainted",
-                                                   "target_fields"};
+auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
+                                                         "config_doc",
+                                                         "config_fields",
+                                                         "config_transitions",
+                                                         "config_vars",
+                                                         "doc",
+                                                         "expression",
+                                                         "field_doc",
+                                                         "implicit",
+                                                         "imports",
+                                                         "import",
+                                                         "string_fields",
+                                                         "tainted",
+                                                         "target_fields"};
 
 [[nodiscard]] auto ReadAnonymousObject(EntityName const& id,
                                        nlohmann::json const& json,
@@ -249,7 +249,7 @@ auto CreateRuleMap(gsl::not_null<RuleFileMap*> const& rule_file_map,
                 if (not reader) {
                     return;
                 }
-                reader->ExpectFields(rule_fields);
+                reader->ExpectFields(kRuleFields);
 
                 auto expr = reader->ReadExpression("expression");
                 if (not expr) {
diff --git a/src/buildtool/build_engine/expression/evaluator.cpp b/src/buildtool/build_engine/expression/evaluator.cpp
index a14b367f..e573bf36 100644
--- a/src/buildtool/build_engine/expression/evaluator.cpp
+++ b/src/buildtool/build_engine/expression/evaluator.cpp
@@ -228,6 +228,7 @@ auto Join(ExpressionPtr const& expr, std::string const& sep) -> ExpressionPtr {
 }
 
 template <bool kDisjoint = false>
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Union(Expression::list_t const& dicts, size_t from, size_t to)
     -> ExpressionPtr {
     if (to <= from) {
@@ -786,7 +787,7 @@ auto AssertNonEmptyExpr(SubExprEvaluator&& eval,
     throw Evaluator::EvaluationError(ss.str(), false, true);
 }
 
-auto built_in_functions =
+auto const kBuiltInFunctions =
     FunctionMap::MakePtr({{"var", VarExpr},
                           {"if", IfExpr},
                           {"cond", CondExpr},
@@ -883,7 +884,7 @@ auto Evaluator::EvaluateExpression(
         return Evaluate(
             expr,
             env,
-            FunctionMap::MakePtr(built_in_functions, provider_functions));
+            FunctionMap::MakePtr(kBuiltInFunctions, provider_functions));
     } catch (EvaluationError const& ex) {
         if (ex.UserContext()) {
             try {
@@ -910,6 +911,7 @@ auto Evaluator::EvaluateExpression(
     return ExpressionPtr{nullptr};
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Evaluator::Evaluate(ExpressionPtr const& expr,
                          Configuration const& env,
                          FunctionMapPtr const& functions) -> ExpressionPtr {
@@ -923,6 +925,7 @@ auto Evaluator::Evaluate(ExpressionPtr const& expr,
                 expr->List().cbegin(),
                 expr->List().cend(),
                 std::back_inserter(list),
+                // NOLINTNEXTLINE(misc-no-recursion)
                 [&](auto const& e) { return Evaluate(e, env, functions); });
             return ExpressionPtr{list};
         }
diff --git a/src/buildtool/build_engine/expression/expression.cpp b/src/buildtool/build_engine/expression/expression.cpp
index 61b5f827..f9e43463 100644
--- a/src/buildtool/build_engine/expression/expression.cpp
+++ b/src/buildtool/build_engine/expression/expression.cpp
@@ -57,6 +57,7 @@ auto Expression::operator[](size_t pos) && -> ExpressionPtr {
         fmt::format("List pos '{}' is out of bounds.", pos)};
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Expression::ToJson(Expression::JsonMode mode) const -> nlohmann::json {
     if (IsBool()) {
         return Bool();
@@ -93,12 +94,14 @@ auto Expression::ToJson(Expression::JsonMode mode) const -> nlohmann::json {
         std::transform(list.begin(),
                        list.end(),
                        std::back_inserter(json),
+                       // NOLINTNEXTLINE(misc-no-recursion)
                        [mode](auto const& e) { return e->ToJson(mode); });
         return json;
     }
     if (IsMap()) {
         auto json = nlohmann::json::object();
         auto const& map = Value<map_t>()->get();
+        // NOLINTNEXTLINE(misc-no-recursion)
         std::for_each(map.begin(), map.end(), [&](auto const& p) {
             json.emplace(p.first, p.second->ToJson(mode));
         });
@@ -110,6 +113,7 @@ auto Expression::ToJson(Expression::JsonMode mode) const -> nlohmann::json {
     return nlohmann::json{};
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Expression::IsCacheable() const -> bool {
     // Must be updated whenever we add a new non-cacheable value
     if (IsName()) {
@@ -138,10 +142,12 @@ auto Expression::IsCacheable() const -> bool {
     return true;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Expression::ToString() const -> std::string {
     return ToJson().dump();
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Expression::ToHash() const noexcept -> std::string {
     if (hash_.load() == nullptr) {
         if (not hash_loading_.exchange(true)) {
@@ -155,6 +161,7 @@ auto Expression::ToHash() const noexcept -> std::string {
     return *hash_.load();
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Expression::FromJson(nlohmann::json const& json) noexcept
     -> ExpressionPtr {
     if (json.is_null()) {
@@ -176,6 +183,7 @@ auto Expression::FromJson(nlohmann::json const& json) noexcept
             std::transform(json.begin(),
                            json.end(),
                            std::back_inserter(l),
+                           // NOLINTNEXTLINE(misc-no-recursion)
                            [](auto const& j) { return FromJson(j); });
             return ExpressionPtr{l};
         }
@@ -209,6 +217,7 @@ auto Expression::TypeString() const noexcept -> std::string {
     return TypeStringForIndex();
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Expression::ComputeHash() const noexcept -> std::string {
     auto hash = std::string{};
     if (IsNone() or IsBool() or IsNumber() or IsString() or IsArtifact() or
diff --git a/src/buildtool/build_engine/target_map/built_in_rules.cpp b/src/buildtool/build_engine/target_map/built_in_rules.cpp
index b5256158..8ff3a9c3 100644
--- a/src/buildtool/build_engine/target_map/built_in_rules.cpp
+++ b/src/buildtool/build_engine/target_map/built_in_rules.cpp
@@ -16,27 +16,30 @@
 
 namespace {
 
-auto genericRuleFields = std::unordered_set<std::string>{"arguments_config",
-                                                         "cmds",
-                                                         "deps",
-                                                         "env",
-                                                         "tainted",
-                                                         "type",
-                                                         "outs"};
-
-auto fileGenRuleFields = std::unordered_set<std::string>{"arguments_config",
-                                                         "data",
-                                                         "deps",
-                                                         "name",
-                                                         "tainted",
-                                                         "type"};
-
-auto installRuleFields = std::unordered_set<std::string>{"arguments_config",
-                                                         "deps",
-                                                         "dirs",
-                                                         "files",
-                                                         "tainted",
-                                                         "type"};
+auto const kGenericRuleFields =
+    std::unordered_set<std::string>{"arguments_config",
+                                    "cmds",
+                                    "deps",
+                                    "env",
+                                    "tainted",
+                                    "type",
+                                    "outs"};
+
+auto const kFileGenRuleFields =
+    std::unordered_set<std::string>{"arguments_config",
+                                    "data",
+                                    "deps",
+                                    "name",
+                                    "tainted",
+                                    "type"};
+
+auto const kInstallRuleFields =
+    std::unordered_set<std::string>{"arguments_config",
+                                    "deps",
+                                    "dirs",
+                                    "files",
+                                    "tainted",
+                                    "type"};
 
 void FileGenRuleWithDeps(
     const std::vector<BuildMaps::Target::ConfiguredTarget>& dependency_keys,
@@ -166,7 +169,7 @@ void FileGenRule(
     const gsl::not_null<BuildMaps::Target::ResultTargetMap*>& result_map) {
     auto desc = BuildMaps::Base::FieldReader::CreatePtr(
         desc_json, key.target, "file-generation target", logger);
-    desc->ExpectFields(fileGenRuleFields);
+    desc->ExpectFields(kFileGenRuleFields);
     auto param_vars = desc->ReadStringList("arguments_config");
     if (not param_vars) {
         return;
@@ -363,7 +366,7 @@ void InstallRule(
     const gsl::not_null<BuildMaps::Target::ResultTargetMap*>& result_map) {
     auto desc = BuildMaps::Base::FieldReader::CreatePtr(
         desc_json, key.target, "install target", logger);
-    desc->ExpectFields(installRuleFields);
+    desc->ExpectFields(kInstallRuleFields);
     auto param_vars = desc->ReadStringList("arguments_config");
     if (not param_vars) {
         return;
@@ -739,7 +742,7 @@ void GenericRule(
     const gsl::not_null<BuildMaps::Target::ResultTargetMap*> result_map) {
     auto desc = BuildMaps::Base::FieldReader::CreatePtr(
         desc_json, key.target, "generic target", logger);
-    desc->ExpectFields(genericRuleFields);
+    desc->ExpectFields(kGenericRuleFields);
     auto param_vars = desc->ReadStringList("arguments_config");
     if (not param_vars) {
         return;
@@ -798,7 +801,7 @@ void GenericRule(
         logger);
 }
 
-auto built_ins = std::unordered_map<
+auto const kBuiltIns = std::unordered_map<
     std::string,
     std::function<void(
         const nlohmann::json&,
@@ -822,7 +825,7 @@ auto IsBuiltInRule(nlohmann::json const& rule_type) -> bool {
         return false;
     }
     auto rule_name = rule_type.get<std::string>();
-    return built_ins.contains(rule_name);
+    return kBuiltIns.contains(rule_name);
 }
 
 auto HandleBuiltin(
@@ -839,8 +842,8 @@ auto HandleBuiltin(
         return false;
     }
     auto rule_name = rule_type.get<std::string>();
-    auto it = built_ins.find(rule_name);
-    if (it == built_ins.end()) {
+    auto it = kBuiltIns.find(rule_name);
+    if (it == kBuiltIns.end()) {
         return false;
     }
     auto target_logger = std::make_shared<BuildMaps::Target::TargetMap::Logger>(
diff --git a/src/buildtool/build_engine/target_map/export.cpp b/src/buildtool/build_engine/target_map/export.cpp
index 73fcbb08..c152b37f 100644
--- a/src/buildtool/build_engine/target_map/export.cpp
+++ b/src/buildtool/build_engine/target_map/export.cpp
@@ -6,12 +6,12 @@
 #include "src/buildtool/build_engine/expression/configuration.hpp"
 
 namespace {
-auto expectedFields = std::unordered_set<std::string>{"config_doc",
-                                                      "doc",
-                                                      "fixed_config",
-                                                      "flexible_config",
-                                                      "target",
-                                                      "type"};
+auto const kExpectedFields = std::unordered_set<std::string>{"config_doc",
+                                                             "doc",
+                                                             "fixed_config",
+                                                             "flexible_config",
+                                                             "target",
+                                                             "type"};
 
 void FinalizeExport(
     const std::vector<AnalysedTargetPtr const*>& exported,
@@ -60,7 +60,7 @@ void ExportRule(
     const gsl::not_null<BuildMaps::Target::ResultTargetMap*> result_map) {
     auto desc = BuildMaps::Base::FieldReader::CreatePtr(
         desc_json, key.target, "export target", logger);
-    desc->ExpectFields(expectedFields);
+    desc->ExpectFields(kExpectedFields);
     auto exported_target_name = desc->ReadExpression("target");
     if (not exported_target_name) {
         return;
diff --git a/src/buildtool/build_engine/target_map/result_map.hpp b/src/buildtool/build_engine/target_map/result_map.hpp
index ee1a0e0b..22c0bd39 100644
--- a/src/buildtool/build_engine/target_map/result_map.hpp
+++ b/src/buildtool/build_engine/target_map/result_map.hpp
@@ -283,6 +283,7 @@ class ResultTargetMap {
     std::vector<std::size_t> num_blobs_{std::vector<std::size_t>(width_)};
     std::vector<std::size_t> num_trees_{std::vector<std::size_t>(width_)};
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     constexpr static auto ComputeWidth(std::size_t jobs) -> std::size_t {
         if (jobs <= 0) {
             // Non-positive indicates to use the default value
diff --git a/src/buildtool/build_engine/target_map/target_map.cpp b/src/buildtool/build_engine/target_map/target_map.cpp
index 159669b7..62ab8c91 100644
--- a/src/buildtool/build_engine/target_map/target_map.cpp
+++ b/src/buildtool/build_engine/target_map/target_map.cpp
@@ -735,12 +735,12 @@ void withDependencies(
         logger(fmt::format("expected list, but got {}", ptr->ToString()));
         return false;
     }
-    for (const auto& entry : ptr->List()) {
-        if (not entry->IsMap()) {
-            logger(fmt::format("expected list of dicts, but found {}",
-                               ptr->ToString()));
-            return false;
-        }
+    if (not std::all_of(ptr->List().begin(),
+                        ptr->List().end(),
+                        [](auto const& entry) { return entry->IsMap(); })) {
+        logger(fmt::format("expected list of dicts, but found {}",
+                           ptr->ToString()));
+        return false;
     }
 
     return true;
diff --git a/src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp b/src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp
index 7005f129..2b8cb677 100644
--- a/src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp
+++ b/src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp
@@ -174,7 +174,8 @@ class BlobContainer {
             }
 
           private:
-            static inline BazelBlob kEmpty{bazel_re::Digest{}, std::string{}};
+            static inline BazelBlob const kEmpty{bazel_re::Digest{},
+                                                 std::string{}};
             gsl::not_null<underlaying_map_t const*> blobs_;
         };
 
diff --git a/src/buildtool/execution_api/bazel_msg/bazel_msg_factory.cpp b/src/buildtool/execution_api/bazel_msg/bazel_msg_factory.cpp
index ff8614f5..9534ab06 100644
--- a/src/buildtool/execution_api/bazel_msg/bazel_msg_factory.cpp
+++ b/src/buildtool/execution_api/bazel_msg/bazel_msg_factory.cpp
@@ -361,6 +361,7 @@ class DirectoryTree {
     }
 
     /// \brief Convert tree to `DirectoryNodeBundle`.
+    /// NOLINTNEXTLINE(misc-no-recursion)
     [[nodiscard]] auto ToBundle(
         std::string const& root_name,
         std::optional<BazelMsgFactory::BlobStoreFunc> const& store_blob,
@@ -410,6 +411,7 @@ class DirectoryTree {
     using Node = std::variant<DirectoryTreePtr, Artifact const*>;
     std::unordered_map<std::string, Node> nodes;
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     [[nodiscard]] auto AddArtifact(std::filesystem::path::iterator* begin,
                                    std::filesystem::path::iterator const& end,
                                    Artifact const* artifact) -> bool {
diff --git a/src/buildtool/execution_api/common/execution_common.hpp b/src/buildtool/execution_api/common/execution_common.hpp
index 8b6aea40..1cf198fe 100644
--- a/src/buildtool/execution_api/common/execution_common.hpp
+++ b/src/buildtool/execution_api/common/execution_common.hpp
@@ -60,7 +60,7 @@
     return dist(urandom);
 }
 
-static auto kRandomConstant = GetNonDeterministicRandomNumber();
+static auto const kRandomConstant = GetNonDeterministicRandomNumber();
 
 static void EncodeUUIDVersion4(std::string* uuid) {
     constexpr auto kVersionByte = 6UL;
diff --git a/src/buildtool/execution_api/local/config.hpp b/src/buildtool/execution_api/local/config.hpp
index 5f3a2a80..3f293b95 100644
--- a/src/buildtool/execution_api/local/config.hpp
+++ b/src/buildtool/execution_api/local/config.hpp
@@ -19,6 +19,24 @@
 
 /// \brief Store global build system configuration.
 class LocalExecutionConfig {
+    struct ConfigData {
+        // User root directory (Unix default: /home/${USER})
+        std::filesystem::path user_root{};
+
+        // Build root directory (default: empty)
+        std::filesystem::path build_root{};
+
+        // Disk cache directory (default: empty)
+        std::filesystem::path disk_cache{};
+
+        // Launcher to be prepended to action's command before executed.
+        // Default: ["env", "--"]
+        std::vector<std::string> launcher{"env", "--"};
+
+        // Persistent build directory option
+        bool keep_build_dir{false};
+    };
+
   public:
     [[nodiscard]] static auto SetBuildRoot(
         std::filesystem::path const& dir) noexcept -> bool {
@@ -28,7 +46,7 @@ class LocalExecutionConfig {
                         dir.string());
             return false;
         }
-        build_root_ = dir;
+        Data().build_root = dir;
         return true;
     }
 
@@ -40,14 +58,14 @@ class LocalExecutionConfig {
                         dir.string());
             return false;
         }
-        disk_cache_ = dir;
+        Data().disk_cache = dir;
         return true;
     }
 
     [[nodiscard]] static auto SetLauncher(
         std::vector<std::string> const& launcher) noexcept -> bool {
         try {
-            launcher_ = launcher;
+            Data().launcher = launcher;
         } catch (std::exception const& e) {
             Logger::Log(LogLevel::Error,
                         "when setting the local launcher\n{}",
@@ -59,63 +77,54 @@ class LocalExecutionConfig {
 
     [[nodiscard]] static auto SetKeepBuildDir(bool is_persistent) noexcept
         -> bool {
-        keep_build_dir_ = is_persistent;
+        Data().keep_build_dir = is_persistent;
         return true;
     }
 
     /// \brief User directory.
     [[nodiscard]] static auto GetUserDir() noexcept -> std::filesystem::path {
-        if (user_root_.empty()) {
-            user_root_ = GetUserRoot() / ".cache" / "just";
+        auto& user_root = Data().user_root;
+        if (user_root.empty()) {
+            user_root = GetUserRoot() / ".cache" / "just";
         }
-        return user_root_;
+        return user_root;
     }
 
     /// \brief Build directory, defaults to user directory if not set
     [[nodiscard]] static auto GetBuildDir() noexcept -> std::filesystem::path {
-        if (build_root_.empty()) {
+        auto& build_root = Data().build_root;
+        if (build_root.empty()) {
             return GetUserDir();
         }
-        return build_root_;
+        return build_root;
     }
 
     /// \brief Cache directory, defaults to user directory if not set
     [[nodiscard]] static auto GetCacheDir() noexcept -> std::filesystem::path {
-        if (disk_cache_.empty()) {
+        auto& disk_cache = Data().disk_cache;
+        if (disk_cache.empty()) {
             return GetBuildDir();
         }
-        return disk_cache_;
+        return disk_cache;
     }
 
     [[nodiscard]] static auto GetLauncher() noexcept
         -> std::vector<std::string> {
-        return launcher_;
+        return Data().launcher;
     }
 
     [[nodiscard]] static auto KeepBuildDir() noexcept -> bool {
-        return keep_build_dir_;
+        return Data().keep_build_dir;
     }
 
   private:
-    // User root directory (Unix default: /home/${USER})
-    static inline std::filesystem::path user_root_{};
-
-    // Build root directory (default: empty)
-    static inline std::filesystem::path build_root_{};
-
-    // Disk cache directory (default: empty)
-    static inline std::filesystem::path disk_cache_{};
-
-    // Launcher to be prepended to action's command before executed.
-    // Default: ["env", "--"]
-    static inline std::vector<std::string> launcher_{"env", "--"};
-
-    // Persistent build directory option
-    static inline bool keep_build_dir_{false};
+    [[nodiscard]] static auto Data() noexcept -> ConfigData& {
+        static ConfigData instance{};
+        return instance;
+    }
 
     /// \brief Determine user root directory
-    [[nodiscard]] static inline auto GetUserRoot() noexcept
-        -> std::filesystem::path {
+    [[nodiscard]] static auto GetUserRoot() noexcept -> std::filesystem::path {
         char const* root{nullptr};
 
 #ifdef __unix__
diff --git a/src/buildtool/execution_api/local/local_action.cpp b/src/buildtool/execution_api/local/local_action.cpp
index 0c71a84b..d8ec8be3 100644
--- a/src/buildtool/execution_api/local/local_action.cpp
+++ b/src/buildtool/execution_api/local/local_action.cpp
@@ -184,21 +184,24 @@ auto LocalAction::CreateDirectoryStructure(
     }
 
     // create output paths
-    for (auto const& local_path : output_files_) {
-        if (not FileSystemManager::CreateDirectory(
-                (exec_path / local_path).parent_path())) {
+    auto const create_dir = [this](auto const& dir) {
+        if (not FileSystemManager::CreateDirectory(dir)) {
             logger_.Emit(LogLevel::Error, "failed to create output directory");
             return false;
         }
-    }
-    for (auto const& local_path : output_dirs_) {
-        if (not FileSystemManager::CreateDirectory(exec_path / local_path)) {
-            logger_.Emit(LogLevel::Error, "failed to create output directory");
-            return false;
-        }
-    }
-
-    return true;
+        return true;
+    };
+    return std::all_of(output_files_.begin(),
+                       output_files_.end(),
+                       [&exec_path, &create_dir](auto const& local_path) {
+                           auto dir = (exec_path / local_path).parent_path();
+                           return create_dir(dir);
+                       }) and
+           std::all_of(output_dirs_.begin(),
+                       output_dirs_.end(),
+                       [&exec_path, &create_dir](auto const& local_path) {
+                           return create_dir(exec_path / local_path);
+                       });
 }
 
 auto LocalAction::CollectOutputFile(std::filesystem::path const& exec_path,
diff --git a/src/buildtool/execution_api/local/local_api.hpp b/src/buildtool/execution_api/local/local_api.hpp
index 96b96416..ebbb10ef 100644
--- a/src/buildtool/execution_api/local/local_api.hpp
+++ b/src/buildtool/execution_api/local/local_api.hpp
@@ -34,6 +34,7 @@ class LocalApi final : public IExecutionApi {
                                                      properties}};
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     [[nodiscard]] auto RetrieveToPaths(
         std::vector<Artifact::ObjectInfo> const& artifacts_info,
         std::vector<std::filesystem::path> const& output_paths) noexcept
diff --git a/src/buildtool/execution_api/local/local_storage.cpp b/src/buildtool/execution_api/local/local_storage.cpp
index c007fc1d..5e4115df 100644
--- a/src/buildtool/execution_api/local/local_storage.cpp
+++ b/src/buildtool/execution_api/local/local_storage.cpp
@@ -23,7 +23,8 @@ namespace {
     gsl::not_null<FILE*> const& stream) noexcept -> bool {
     if (auto dir = ReadDirectory(storage, tree_digest)) {
         if (auto data = BazelMsgFactory::DirectoryToString(*dir)) {
-            std::fwrite(data->data(), 1, data->size(), stream);
+            auto const& str = *data;
+            std::fwrite(str.data(), 1, str.size(), stream);
             return true;
         }
     }
@@ -71,6 +72,7 @@ auto LocalStorage::ReadTreeInfos(
     return std::nullopt;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto LocalStorage::ReadObjectInfosRecursively(
     BazelMsgFactory::InfoStoreFunc const& store_info,
     std::filesystem::path const& parent,
@@ -79,19 +81,22 @@ auto LocalStorage::ReadObjectInfosRecursively(
     if (tree_map_) {
         auto const* tree = tree_map_->GetTree(digest);
         if (tree != nullptr) {
-            for (auto const& [path, info] : *tree) {
-                try {
-                    if (IsTreeObject(info->type)
-                            ? not ReadObjectInfosRecursively(
-                                  store_info, parent / path, info->digest)
-                            : not store_info(parent / path, *info)) {
+            return std::all_of(
+                tree->begin(),
+                tree->end(),
+                // NOLINTNEXTLINE(misc-no-recursion)
+                [this, &store_info, &parent](auto const& entry) {
+                    try {
+                        auto const& [path, info] = entry;
+                        return IsTreeObject(info->type)
+                                   ? ReadObjectInfosRecursively(store_info,
+                                                                parent / path,
+                                                                info->digest)
+                                   : store_info(parent / path, *info);
+                    } catch (...) {  // satisfy clang-tidy, store_info() could
                         return false;
                     }
-                } catch (...) {  // satisfy clang-tidy, store_info() could throw
-                    return false;
-                }
-            }
-            return true;
+                });
         }
         Logger::Log(
             LogLevel::Debug, "tree {} not found in tree map", digest.hash());
diff --git a/src/buildtool/execution_api/local/local_storage.hpp b/src/buildtool/execution_api/local/local_storage.hpp
index a071a5d5..568d412d 100644
--- a/src/buildtool/execution_api/local/local_storage.hpp
+++ b/src/buildtool/execution_api/local/local_storage.hpp
@@ -52,6 +52,7 @@ class LocalStorage {
     }
 
     /// \brief Obtain blob path from digest with x-bit.
+    /// NOLINTNEXTLINE(misc-no-recursion)
     [[nodiscard]] auto BlobPath(bazel_re::Digest const& digest,
                                 bool is_executable) const noexcept
         -> std::optional<std::filesystem::path> {
@@ -91,6 +92,7 @@ class LocalStorage {
     /// \param digest        Blob digest.
     /// \param to_executable Sync direction.
     /// \returns Path to blob in target CAS.
+    /// NOLINTNEXTLINE(misc-no-recursion)
     [[nodiscard]] auto TrySyncBlob(bazel_re::Digest const& digest,
                                    bool to_executable) const noexcept
         -> std::optional<std::filesystem::path> {
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_api.cpp b/src/buildtool/execution_api/remote/bazel/bazel_api.cpp
index 05d9c357..28425400 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_api.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_api.cpp
@@ -53,6 +53,7 @@ auto BazelApi::CreateAction(
                                                         properties}};
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 [[nodiscard]] auto BazelApi::RetrieveToPaths(
     std::vector<Artifact::ObjectInfo> const& artifacts_info,
     std::vector<std::filesystem::path> const& output_paths) noexcept -> bool {
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_cas_client.cpp b/src/buildtool/execution_api/remote/bazel/bazel_cas_client.cpp
index 87ceb4ae..da8b518c 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_cas_client.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_cas_client.cpp
@@ -94,6 +94,7 @@ auto BazelCasClient::BatchReadBlobs(
     return result;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto BazelCasClient::GetTree(std::string const& instance_name,
                              bazel_re::Digest const& root_digest,
                              std::int32_t page_size,
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_network.cpp b/src/buildtool/execution_api/remote/bazel/bazel_network.cpp
index ea502480..ee31d5ee 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_network.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_network.cpp
@@ -26,7 +26,8 @@ namespace {
     gsl::not_null<FILE*> const& stream) noexcept -> bool {
     if (auto dir = ReadDirectory(network, tree_digest)) {
         if (auto data = BazelMsgFactory::DirectoryToString(*dir)) {
-            std::fwrite(data->data(), 1, data->size(), stream);
+            auto const& str = *data;
+            std::fwrite(str.data(), 1, str.size(), stream);
             return true;
         }
     }
@@ -40,7 +41,8 @@ namespace {
     auto reader = network->IncrementalReadSingleBlob(blob_digest);
     auto data = reader.Next();
     while (data and not data->empty()) {
-        std::fwrite(data->data(), 1, data->size(), stream);
+        auto const& str = *data;
+        std::fwrite(str.data(), 1, str.size(), stream);
         data = reader.Next();
     }
     return data.has_value();
@@ -242,6 +244,7 @@ auto BazelNetwork::ReadTreeInfos(bazel_re::Digest const& tree_digest,
     return std::nullopt;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 auto BazelNetwork::ReadObjectInfosRecursively(
     std::optional<DirectoryMap> const& dir_map,
     BazelMsgFactory::InfoStoreFunc const& store_info,
@@ -251,21 +254,24 @@ auto BazelNetwork::ReadObjectInfosRecursively(
     if (tree_map_) {
         auto const* tree = tree_map_->GetTree(digest);
         if (tree != nullptr) {
-            for (auto const& [path, info] : *tree) {
-                try {
-                    if (IsTreeObject(info->type)
-                            ? not ReadObjectInfosRecursively(dir_map,
-                                                             store_info,
-                                                             parent / path,
-                                                             info->digest)
-                            : not store_info(parent / path, *info)) {
+            return std::all_of(
+                tree->begin(),
+                tree->end(),
+                // NOLINTNEXTLINE(misc-no-recursion)
+                [this, &dir_map, &store_info, &parent](auto const& entry) {
+                    auto const& [path, info] = entry;
+                    try {
+                        return IsTreeObject(info->type)
+                                   ? ReadObjectInfosRecursively(dir_map,
+                                                                store_info,
+                                                                parent / path,
+                                                                info->digest)
+                                   : store_info(parent / path, *info);
+                    } catch (
+                        ...) {  // satisfy clang-tidy, store_info() could throw
                         return false;
                     }
-                } catch (...) {  // satisfy clang-tidy, store_info() could throw
-                    return false;
-                }
-            }
-            return true;
+                });
         }
         Logger::Log(
             LogLevel::Debug, "tree {} not found in tree map", digest.hash());
diff --git a/src/buildtool/execution_api/remote/bazel/bytestream_client.hpp b/src/buildtool/execution_api/remote/bazel/bytestream_client.hpp
index b8823236..1bd44c42 100644
--- a/src/buildtool/execution_api/remote/bazel/bytestream_client.hpp
+++ b/src/buildtool/execution_api/remote/bazel/bytestream_client.hpp
@@ -1,6 +1,7 @@
 #ifndef INCLUDED_SRC_BUILDTOOL_EXECUTION_API_REMOTE_BAZEL_BYTESTREAM_CLIENT_HPP
 #define INCLUDED_SRC_BUILDTOOL_EXECUTION_API_REMOTE_BAZEL_BYTESTREAM_CLIENT_HPP
 
+#include <algorithm>
 #include <functional>
 #include <iomanip>
 #include <optional>
@@ -156,12 +157,11 @@ class ByteStreamClient {
         std::function<std::string(T_Input const&)> const& to_resource_name,
         std::function<std::string(T_Input const&)> const& to_data)
         const noexcept -> bool {
-        for (auto const& i : inputs) {
-            if (not Write(to_resource_name(i), to_data(i))) {
-                return false;
-            }
-        }
-        return true;
+        return std::all_of(inputs.begin(),
+                           inputs.end(),
+                           [this, &to_resource_name, &to_data](auto const& i) {
+                               return Write(to_resource_name(i), to_data(i));
+                           });
     }
 
   private:
diff --git a/src/buildtool/execution_engine/dag/dag.cpp b/src/buildtool/execution_engine/dag/dag.cpp
index 5d60dd01..6eb492a8 100644
--- a/src/buildtool/execution_engine/dag/dag.cpp
+++ b/src/buildtool/execution_engine/dag/dag.cpp
@@ -96,22 +96,18 @@ auto DependencyGraph::LinkNodePointers(
 
 auto DependencyGraph::Add(std::vector<ActionDescription> const& actions)
     -> bool {
-    for (auto const& action : actions) {
-        if (not AddAction(action)) {
-            return false;
-        }
-    }
-    return true;
+    return std::all_of(
+        actions.begin(), actions.end(), [this](auto const& action) {
+            return AddAction(action);
+        });
 }
 
 auto DependencyGraph::Add(std::vector<ActionDescription::Ptr> const& actions)
     -> bool {
-    for (auto const& action : actions) {
-        if (not AddAction(*action)) {
-            return false;
-        }
-    }
-    return true;
+    return std::all_of(
+        actions.begin(), actions.end(), [this](auto const& action) {
+            return AddAction(*action);
+        });
 }
 
 auto DependencyGraph::AddArtifact(ArtifactDescription const& description)
diff --git a/src/buildtool/execution_engine/dag/dag.hpp b/src/buildtool/execution_engine/dag/dag.hpp
index 500ff0fc..bcc0cd48 100644
--- a/src/buildtool/execution_engine/dag/dag.hpp
+++ b/src/buildtool/execution_engine/dag/dag.hpp
@@ -163,6 +163,7 @@ class DirectedAcyclicGraph {
 
   protected:
     template <typename T_Node>
+    // NOLINTNEXTLINE(misc-no-recursion)
     [[nodiscard]] static auto check_validity(
         gsl::not_null<T_Node*> node) noexcept -> bool {
         // Check node-specified validity (e.g. bipartiteness requirements)
@@ -560,13 +561,13 @@ class DependencyGraph : DirectedAcyclicGraph {
         -> std::optional<ActionIdentifier>;
 
     [[nodiscard]] auto IsValid() const noexcept -> bool {
-        for (auto const& node : artifact_nodes_) {
-            if (!DirectedAcyclicGraph::check_validity<
-                    std::remove_reference_t<decltype(*node)>>(&(*node))) {
-                return false;
-            }
-        }
-        return true;
+        return std::all_of(
+            artifact_nodes_.begin(),
+            artifact_nodes_.end(),
+            [](auto const& node) {
+                return DirectedAcyclicGraph::check_validity<
+                    std::remove_reference_t<decltype(*node)>>(&(*node));
+            });
     }
 
   private:
diff --git a/src/buildtool/execution_engine/executor/executor.hpp b/src/buildtool/execution_engine/executor/executor.hpp
index d46c290b..94c32b1f 100644
--- a/src/buildtool/execution_engine/executor/executor.hpp
+++ b/src/buildtool/execution_engine/executor/executor.hpp
@@ -237,12 +237,10 @@ class ExecutorImpl {
     [[nodiscard]] static auto CheckOutputsExist(
         IExecutionResponse::ArtifactInfos const& artifacts,
         std::vector<Action::LocalPath> const& outputs) noexcept -> bool {
-        for (auto const& output : outputs) {
-            if (not artifacts.contains(output)) {
-                return false;
-            }
-        }
-        return true;
+        return std::all_of(
+            outputs.begin(), outputs.end(), [&artifacts](auto const& output) {
+                return artifacts.contains(output);
+            });
     }
 
     /// \brief Parse response and write object info to DAG's artifact nodes.
diff --git a/src/buildtool/file_system/git_cas.cpp b/src/buildtool/file_system/git_cas.cpp
index e77d8d6e..67091d2f 100644
--- a/src/buildtool/file_system/git_cas.cpp
+++ b/src/buildtool/file_system/git_cas.cpp
@@ -1,5 +1,6 @@
 #include "src/buildtool/file_system/git_cas.hpp"
 
+#include <mutex>
 #include <sstream>
 
 #include "src/buildtool/file_system/file_system_manager.hpp"
@@ -154,9 +155,10 @@ auto GitCAS::ReadHeader(std::string const& id, bool is_hex_id) const noexcept
 }
 
 auto GitCAS::OpenODB(std::filesystem::path const& repo_path) noexcept -> bool {
+    static std::mutex repo_mutex{};
     if (initialized_) {
         {  // lock as git_repository API has no thread-safety guarantees
-            std::unique_lock lock{repo_mutex_};
+            std::unique_lock lock{repo_mutex};
             git_repository* repo = nullptr;
             if (git_repository_open(&repo, repo_path.c_str()) != 0) {
                 Logger::Log(LogLevel::Error,
diff --git a/src/buildtool/file_system/git_cas.hpp b/src/buildtool/file_system/git_cas.hpp
index d4341482..c964a739 100644
--- a/src/buildtool/file_system/git_cas.hpp
+++ b/src/buildtool/file_system/git_cas.hpp
@@ -3,7 +3,6 @@
 
 #include <filesystem>
 #include <memory>
-#include <mutex>
 #include <optional>
 
 #include "src/buildtool/file_system/object_type.hpp"
@@ -49,7 +48,6 @@ class GitCAS {
         -> std::optional<std::pair<std::size_t, ObjectType>>;
 
   private:
-    static inline std::mutex repo_mutex_{};
     git_odb* odb_{nullptr};
     bool initialized_{false};
 
diff --git a/src/buildtool/file_system/git_tree.cpp b/src/buildtool/file_system/git_tree.cpp
index 3e98ead1..1805961c 100644
--- a/src/buildtool/file_system/git_tree.cpp
+++ b/src/buildtool/file_system/git_tree.cpp
@@ -78,6 +78,7 @@ auto ParseRawTreeObject(GitCASPtr const& cas,
     return (normalized / "").parent_path();  // strip trailing slash
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 [[nodiscard]] auto LookupEntryPyPath(
     GitTree const& tree,
     std::filesystem::path::const_iterator it,
diff --git a/src/buildtool/logging/log_config.hpp b/src/buildtool/logging/log_config.hpp
index 799a6ad5..05b5363c 100644
--- a/src/buildtool/logging/log_config.hpp
+++ b/src/buildtool/logging/log_config.hpp
@@ -10,33 +10,44 @@
 /// \brief Global static logging configuration.
 /// The entire class is thread-safe.
 class LogConfig {
+    struct ConfigData {
+        std::mutex mutex{};
+        LogLevel log_limit{LogLevel::Info};
+        std::vector<ILogSink::Ptr> sinks{};
+        std::vector<LogSinkFactory> factories{};
+    };
+
   public:
     /// \brief Set the log limit.
-    static void SetLogLimit(LogLevel level) noexcept { log_limit_ = level; }
+    static void SetLogLimit(LogLevel level) noexcept {
+        Data().log_limit = level;
+    }
 
     /// \brief Replace all configured sinks.
     /// NOTE: Reinitializes all internal factories.
     static void SetSinks(std::vector<LogSinkFactory>&& factories) noexcept {
-        std::lock_guard lock{mutex_};
-        sinks_.clear();
-        sinks_.reserve(factories.size());
+        auto& data = Data();
+        std::lock_guard lock{data.mutex};
+        data.sinks.clear();
+        data.sinks.reserve(factories.size());
         std::transform(factories.cbegin(),
                        factories.cend(),
-                       std::back_inserter(sinks_),
+                       std::back_inserter(data.sinks),
                        [](auto& f) { return f(); });
-        factories_ = std::move(factories);
+        data.factories = std::move(factories);
     }
 
     /// \brief Add new a new sink.
     static void AddSink(LogSinkFactory&& factory) noexcept {
-        std::lock_guard lock{mutex_};
-        sinks_.push_back(factory());
-        factories_.push_back(std::move(factory));
+        auto& data = Data();
+        std::lock_guard lock{data.mutex};
+        data.sinks.push_back(factory());
+        data.factories.push_back(std::move(factory));
     }
 
     /// \brief Get the currently configured log limit.
     [[nodiscard]] static auto LogLimit() noexcept -> LogLevel {
-        return log_limit_;
+        return Data().log_limit;
     }
 
     /// \brief Get sink instances for all configured sink factories.
@@ -45,8 +56,9 @@ class LogConfig {
     // NOLINTNEXTLINE(readability-const-return-type)
     [[nodiscard]] static auto Sinks() noexcept
         -> std::vector<ILogSink::Ptr> const {
-        std::lock_guard lock{mutex_};
-        return sinks_;
+        auto& data = Data();
+        std::lock_guard lock{data.mutex};
+        return data.sinks;
     }
 
     /// \brief Get all configured sink factories.
@@ -55,15 +67,16 @@ class LogConfig {
     // NOLINTNEXTLINE(readability-const-return-type)
     [[nodiscard]] static auto SinkFactories() noexcept
         -> std::vector<LogSinkFactory> const {
-        std::lock_guard lock{mutex_};
-        return factories_;
+        auto& data = Data();
+        std::lock_guard lock{data.mutex};
+        return data.factories;
     }
 
   private:
-    static inline std::mutex mutex_{};
-    static inline LogLevel log_limit_{LogLevel::Info};
-    static inline std::vector<ILogSink::Ptr> sinks_{};
-    static inline std::vector<LogSinkFactory> factories_{};
+    [[nodiscard]] static auto Data() noexcept -> ConfigData& {
+        static ConfigData instance{};
+        return instance;
+    }
 };
 
 #endif  // INCLUDED_SRC_BUILDTOOL_LOGGING_LOG_CONFIG_HPP
diff --git a/src/buildtool/logging/log_sink_cmdline.hpp b/src/buildtool/logging/log_sink_cmdline.hpp
index b726f789..0eef3589 100644
--- a/src/buildtool/logging/log_sink_cmdline.hpp
+++ b/src/buildtool/logging/log_sink_cmdline.hpp
@@ -29,6 +29,7 @@ class LogSinkCmdLine final : public ILogSink {
     void Emit(Logger const* logger,
               LogLevel level,
               std::string const& msg) const noexcept final {
+        static std::mutex mutex{};
         auto prefix = LogLevelToString(level);
 
         if (logger != nullptr) {
@@ -45,7 +46,7 @@ class LogSinkCmdLine final : public ILogSink {
         }
 
         {
-            std::lock_guard lock{mutex_};
+            std::lock_guard lock{mutex};
             if (msg_on_continuation) {
                 fmt::print(stderr, "{}\n", prefix);
                 prefix = cont_prefix;
@@ -62,7 +63,6 @@ class LogSinkCmdLine final : public ILogSink {
 
   private:
     bool colored_{};
-    static inline std::mutex mutex_{};
 
     [[nodiscard]] auto FormatPrefix(LogLevel level,
                                     std::string const& prefix) const noexcept
diff --git a/src/buildtool/logging/log_sink_file.hpp b/src/buildtool/logging/log_sink_file.hpp
index 2ca1b75b..e731a0c1 100644
--- a/src/buildtool/logging/log_sink_file.hpp
+++ b/src/buildtool/logging/log_sink_file.hpp
@@ -61,7 +61,7 @@ class LogSinkFile final : public ILogSink {
     LogSinkFile(std::filesystem::path const& file_path, Mode file_mode)
         : file_path_{std::filesystem::weakly_canonical(file_path).string()} {
         // create file mutex for canonical path
-        file_mutexes_.Create(file_path_, [&] {
+        FileMutexes().Create(file_path_, [&] {
             if (file_mode == Mode::Overwrite) {
                 // clear file contents
                 if (gsl::owner<FILE*> file =
@@ -108,7 +108,7 @@ class LogSinkFile final : public ILogSink {
         auto cont_prefix = std::string(prefix.size(), ' ');
 
         {
-            std::lock_guard lock{file_mutexes_.Get(file_path_)};
+            std::lock_guard lock{FileMutexes().Get(file_path_)};
             if (gsl::owner<FILE*> file = std::fopen(file_path_.c_str(), "a")) {
                 using it = std::istream_iterator<ILogSink::Line>;
                 std::istringstream iss{msg};
@@ -123,7 +123,11 @@ class LogSinkFile final : public ILogSink {
 
   private:
     std::string file_path_{};
-    static inline MutexMap<std::string> file_mutexes_{};
+
+    [[nodiscard]] static auto FileMutexes() noexcept -> MutexMap<std::string>& {
+        static MutexMap<std::string> instance{};
+        return instance;
+    }
 };
 
 #endif  // INCLUDED_SRC_BUILDTOOL_LOGGING_LOG_SINK_FILE_HPP
diff --git a/src/buildtool/main/main.cpp b/src/buildtool/main/main.cpp
index 56b31074..0aeca7b8 100644
--- a/src/buildtool/main/main.cpp
+++ b/src/buildtool/main/main.cpp
@@ -814,6 +814,7 @@ auto DumpExpressionToMap(gsl::not_null<nlohmann::json*> const& map,
     return false;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void DumpNodesInExpressionToMap(gsl::not_null<nlohmann::json*> const& map,
                                 ExpressionPtr const& expr) {
     if (expr->IsNode()) {
diff --git a/src/utils/cpp/json.hpp b/src/utils/cpp/json.hpp
index a231f34b..ca928ac2 100644
--- a/src/utils/cpp/json.hpp
+++ b/src/utils/cpp/json.hpp
@@ -31,6 +31,7 @@ auto ExtractValueAs(
 
 namespace detail {
 
+// NOLINTNEXTLINE(misc-no-recursion)
 [[nodiscard]] static inline auto IndentListsOnlyUntilDepth(
     nlohmann::json const& json,
     std::string const& indent,