Updating default compiler for static analysis tools

.cppcheck_suppress

@@ -35,9 +35,12 @@ missingInclude
 *:*CLI11.hpp
 *:*json.hpp
 *:*boost_unordered.hpp
+*:fmt/*.h
 # Problem caused by external files
 toomanyconfigs
 # More problems caused by external files -- with too many ifdefs
 normalCheckLevelMaxBranches
 # This seems not to work with the designs used here
 duplInheritedMember
+# Seems like iterator variables for std::views disagree with this
+constStatement

src/adapter_matcher.cpp

@@ -131,6 +131,7 @@ y: {},
 type: "line",
 name: "{}",
 }})";
+  // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
   assert(std::size(groups) == std::size(adap_counts));
   // calcualte the x axis first
   const auto x = groups | std::views::transform([&](const auto &g) {
@@ -146,9 +147,9 @@ name: "{}",
     std::ranges::transform(cumulative[curr], cumulative[prev],
                            std::begin(cumulative[curr]), std::plus{});
 #endif
-  const auto n_pos = max_read_len + 1 >= adapter_size
-                       ? max_read_len - adapter_size + 1
-                       : max_read_len;
+  // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
+  const auto n_pos =
+    max_read_len + 1 > adapter_size ? (max_read_len + 1) - adapter_size : 0U;
   const auto last_group_to_keep = std::ranges::find_if(
     groups, [&](const auto &g) { return n_pos <= g.first; });
   cumulative.resize(std::distance(std::cbegin(groups), last_group_to_keep));
@@ -164,13 +165,15 @@ name: "{}",
       return pct_of_reads(cumul[adap_id]);
     };
     const auto y = cumulative | std::views::transform(make_y);
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
     html_by_adapter.emplace_back(fmt::format(adapter_fmt, x, y, adap_name));
   }
   const auto grade = grades.grade(label);
   const auto title = grades.get_title(label);
-  return fmt::format(
-    html_module_fmt, grade, label, title, grade,
-    std::format(plot_fmt, fmt::format("[{:n:}]", html_by_adapter)));
+  const auto the_plot =
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
+    std::format(plot_fmt, fmt::format("[{:n:}]", html_by_adapter));
+  return fmt::format(html_module_fmt, grade, label, title, grade, the_plot);
 }
 
 auto

src/adapter_set.cpp

@@ -39,7 +39,8 @@ load_adapters(const std::string &filename) {
     // ADS: need to make sure this can't fail
     line.remove_suffix(std::size(line) - to_keep_suffix - 1);
     std::string cleaned_line;
-    for (auto itr = std::cbegin(line); itr != std::cend(line); ++itr)
+    for (auto itr = std::cbegin(line); itr != std::cend(line);
+         itr = std::next(itr))
       if (!std::isblank(*itr) ||
           (std::next(itr) != std::cend(line) && *itr != *std::next(itr)))
         cleaned_line += *itr;

src/bam_file.cpp

@@ -19,7 +19,9 @@
 #include <stdexcept>
 #include <string>
 #include <system_error>
+#include <tuple>
 #include <utility>
+#include <vector>
 
 [[nodiscard]] auto
 estimate_n_reads_bam(const std::string &filename)
@@ -63,8 +65,8 @@ estimate_n_reads_bam(const std::string &filename)
 }
 
 [[nodiscard]] auto
-init_dups(const std::string &filename,
-          const std::uint64_t n_unique) -> dups_map_t {
+init_dups(const std::string &filename, const std::uint64_t n_unique)
+  -> dups_map_t {
   static constexpr auto complem = [](const auto x) {
     return "TNGNNNCNNNNNNNNNNNNA"[x - 'A'];
   };

src/bam_file.hpp

@@ -62,7 +62,10 @@ class bam_file {
   ~bam_file() = default;
   // clang-format on
 
-  [[nodiscard]] operator bool() const { return !had_last_chunks; }
+  [[nodiscard]]
+  operator bool() const {
+    return !had_last_chunks;
+  }
 
   friend auto
   reset(bam_file &reads_file) -> void;
@@ -121,8 +124,8 @@ estimate_n_reads_bam(const std::string &filename)
   -> std::tuple<std::uint64_t, std::uint64_t, std::int64_t>;
 
 [[nodiscard]] auto
-init_dups(const std::string &filename,
-          const std::uint64_t n_unique) -> dups_map_t;
+init_dups(const std::string &filename, const std::uint64_t n_unique)
+  -> dups_map_t;
 
 inline auto
 make_tasks(bam_file &reads_file,          //

src/base_groups.hpp

@@ -23,16 +23,16 @@ make_base_groups(const std::uint64_t n_bases, const std::uint64_t n_initial,
                  const std::uint64_t n_groups_target) -> base_group_vec;
 
 [[nodiscard]] auto
-get_default_base_groups(const std::uint64_t n_bases,
-                        const bool make_groups) -> base_group_vec;
+get_default_base_groups(const std::uint64_t n_bases, const bool make_groups)
+  -> base_group_vec;
 
 [[nodiscard]] auto
 make_group_tag(const base_group_t g) -> std::string;
 
 [[nodiscard]] auto
 make_group_tag_quoted(const base_group_t g) -> std::string;
 
-[[nodiscard]] auto
+void
 apply_base_groups(const base_group_vec &groups, auto &rows) {
   assert(std::size(rows) <= groups.back().second);
   auto group_itr = std::cbegin(groups);
@@ -50,7 +50,7 @@ apply_base_groups(const base_group_vec &groups, auto &rows) {
   rows.resize(current_row);
 }
 
-[[nodiscard]] auto
+void
 apply_base_groups(const base_group_vec &groups, auto &rows, const auto &adder) {
   assert(std::size(rows) <= groups.back().second);
   auto group_itr = std::cbegin(groups);

src/bgzf_reader.cpp

@@ -7,6 +7,7 @@
 #include <cassert>
 #include <cerrno>
 #include <cstdint>
+#include <cstdio>
 #include <cstring>
 #include <filesystem>
 #include <memory>
@@ -28,6 +29,7 @@ get_unaligned_le32(const auto p) -> std::int32_t {
 get_isize(const auto data, const auto data_size) {
   static constexpr decltype(data_size) isize_size = 4;
   assert(data_size > isize_size);
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const auto data_isize = data + data_size - isize_size;
   return data_size < isize_size ? 0 : get_unaligned_le32(data_isize);
 }
@@ -50,7 +52,8 @@ bgzf_reader::bgzf_reader(const std::string &filename,
   next_in{inbuf.get()},                                       //
   end_in{inbuf.get()},                                        //
   next_out{outbuf.get()},                                     //
-  end_out{outbuf.get() + buf_size}                            //
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+  end_out{outbuf.get() + buf_size}  //
 {}
 
 [[nodiscard]] auto

src/contaminants.cpp

@@ -11,6 +11,7 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <tuple>  // for std::get
 #include <utility>
 #include <vector>
 
@@ -197,7 +198,8 @@ load_contaminants(const std::string &filename) -> void {
       continue;
     line.remove_suffix(std::size(line) - to_keep_suffix - 1);
     std::string cleaned_line;
-    for (auto itr = std::cbegin(line); itr != std::cend(line); ++itr)
+    for (auto itr = std::cbegin(line); itr != std::cend(line);
+         itr = std::next(itr))
       if (!std::isblank(*itr) ||
           (std::next(itr) != std::cend(line) && *itr != *std::next(itr)))
         cleaned_line += *itr;

src/contaminants.hpp

@@ -4,6 +4,7 @@
 #define SRC_CONTAMINANTS_HPP_
 
 #include <cstdint>
+#include <ranges>  // for std::pair
 #include <string>
 #include <utility>  // IWYU pragma: keep
 #include <vector>

src/duplication_results.cpp

@@ -11,6 +11,7 @@
 #include "run_mode.hpp"
 
 #define FMT_HEADER_ONLY
+#include "fmt/base.h"
 #include "fmt/format.h"
 #include "fmt/ranges.h"
 
@@ -124,8 +125,8 @@ duplication_results::get_overrepresented(const std::uint64_t n_reads) const
 }
 
 auto
-duplication_results::initialize(const run_mode &mode,
-                                const file_info &info) -> void {
+duplication_results::initialize(const run_mode &mode, const file_info &info)
+  -> void {
   read_skip =
     info.n_reads_est < max_n_reads_total
       ? 0
@@ -282,8 +283,8 @@ get_grade_duplication(const dup_summary_t &summary) -> std::string {
 }
 
 [[nodiscard]] auto
-duplication_report(const dup_summary_t &summary,
-                   const file_grades &grades) -> std::string {
+duplication_report(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "duplication";
   static constexpr auto start_tag = ">>Sequence Duplication Levels\t{}\n"
                                     "#Total Deduplicated Percentage\t{:.6f}\n";
@@ -305,9 +306,10 @@ duplication_report(const dup_summary_t &summary,
             std::max(static_cast<std::uint64_t>(1), reduce(summary.hist_mass)));
   auto r = std::format(start_tag, grades.grade(label), pct(frac_dedup));
   r += header;
-  for (const auto [label, mass] :
+  for (const auto [bin_label, mass] :
        std::views::zip(bin_labels, binned_mass_pct) | std::views::drop(1))
-    r += std::format("{}\t{:.3g}\n", label, mass);  // Percentage format is .3g
+    r +=
+      std::format("{}\t{:.3g}\n", bin_label, mass);  // Percentage format is .3g
   return r + end_module_tag;
 }
 
@@ -345,8 +347,8 @@ overrepresented_html(const std::vector<overrep_t> &overrep,
 }
 
 [[nodiscard]] auto
-duplication_html(const dup_summary_t &summary,
-                 const file_grades &grades) -> std::string {
+duplication_html(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string {
   static constexpr auto label = "duplication";
   static constexpr auto plot_format = R"(<div id="duplication_plot"></div>
 <script>Plotly.newPlot("duplication_plot",
@@ -389,11 +391,12 @@ yaxis: {{title: "% of sequences"}},
   };
   const auto grade = grades.grade(label);
   const auto title = grades.get_title(label);
-  return fmt::format(
-    html_module_fmt, grade, label, title, grade,
+  const auto the_plot =
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.UninitializedObject)
     fmt::format(plot_format,                                          //
                 x, to_pct(summary.hist_mass) | std::views::drop(1),   // y_tot,
                 x, to_pct(summary.hist_dedup) | std::views::drop(1),  // y_dedup
                 x, x_text | std::views::drop(1)  // tickvals
-                ));
+    );
+  return fmt::format(html_module_fmt, grade, label, title, grade, the_plot);
 }

src/duplication_results.hpp

@@ -39,7 +39,7 @@ struct dups_init_t {
   std::int64_t count_at_limit{};
   dups_map_t dups_zero;
   dups_init_t() = default;
-  dups_init_t(const dups_map_t &dups) {
+  explicit dups_init_t(const dups_map_t &dups) {
     const auto vals = dups | std::views::values;
     count_at_limit = static_cast<std::int64_t>(
       std::reduce(std::cbegin(vals), std::cend(vals)));
@@ -113,12 +113,12 @@ struct duplication_results {
 get_grade_duplication(const dup_summary_t &summary) -> std::string;
 
 [[nodiscard]] auto
-duplication_report(const dup_summary_t &summary,
-                   const file_grades &grades) -> std::string;
+duplication_report(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string;
 
 [[nodiscard]] auto
-duplication_html(const dup_summary_t &summary,
-                 const file_grades &grades) -> std::string;
+duplication_html(const dup_summary_t &summary, const file_grades &grades)
+  -> std::string;
 
 [[nodiscard]] auto
 get_grade_overrepresented(const std::uint64_t n_reads,

src/falco_analyzer.cpp

@@ -20,6 +20,7 @@
 #include <mutex>
 #include <ranges>
 #include <thread>
+#include <tuple>  // for std::get (iwyu fp)
 #include <utility>
 #include <variant>
 #include <vector>
@@ -34,7 +35,6 @@ analyze(const std::uint32_t n_threads, const run_mode &mode,
   const std::int32_t n_files = static_cast<std::int32_t>(std::size(infos));
   if (dups_init.empty())
     dups_init.resize(n_files);
-  std::vector<std::atomic_int32_t> n_tasks(n_files);
   std::atomic_uint32_t n_active_files{static_cast<std::uint32_t>(n_files)};
   auto results =
     std::vector(n_threads, std::vector<results_collector>(n_files));
@@ -45,6 +45,7 @@ analyze(const std::uint32_t n_threads, const run_mode &mode,
     tq.push(file_id, std::monostate{});
 
   {  // scope to join jthreads
+    std::vector<std::atomic_int32_t> n_tasks(n_files);
     std::vector<std::jthread> workers;
     for (const auto th_id : std::views::iota(0u, n_threads))
       workers.emplace_back([&, n_threads, th_id] {

src/falco_config.cpp

@@ -41,8 +41,8 @@ split(const std::string &s) {
 }
 
 auto
-load_config_and_set_graders(const std::string &filename,
-                            run_mode &mode) -> void {
+load_config_and_set_graders(const std::string &filename, run_mode &mode)
+  -> void {
   // ADS: (todo) handle carriage returns and other control chars
   std::ifstream in(filename);
   if (!in)
@@ -61,9 +61,10 @@ load_config_and_set_graders(const std::string &filename,
   }
 
   // modes
-  for (const auto &label : run_mode::get_labels())
+  std::ranges::for_each(run_mode::get_labels(), [&](const auto &label) {
     if (json_in.contains(label) && !json_in[label].contains("ignore"))
       throw std::runtime_error("invalid config: " + to_string(json_in[label]));
+  });
 
   std::unordered_map<std::string, bool> modes_in;
   try {
@@ -83,11 +84,12 @@ load_config_and_set_graders(const std::string &filename,
   mode.assign(modes_in);
 
   // grades
-  for (const auto &label : grade_labels)
-    if (json_in.contains(label) &&
-        !(json_in[label].contains("error") && json_in[label].contains("warn")))
-      throw std::runtime_error("missing config value for: " +
-                               std::string(label));
+  std::ranges::for_each(grade_labels, [&](const auto &l) {
+    if (json_in.contains(l) &&
+        !(json_in[l].contains("error") && json_in[l].contains("warn")))
+      throw std::runtime_error("missing config value for: " + std::string(l));
+  });
+
   std::unordered_map<std::string, grader> graders;
   try {
     for (const auto &label : grade_labels) {

src/falco_file_format.cpp

@@ -7,7 +7,11 @@
 #include <array>
 #include <cstdlib>
 #include <filesystem>
+#include <iterator>
+#include <memory>
 #include <stdexcept>
+#include <string>
+#include <tuple>
 
 [[nodiscard]] auto
 get_file_format(const std::string &filename)

src/falco_file_format.hpp

@@ -7,8 +7,6 @@
 
 #include <cstdint>
 #include <format>
-#include <iterator>
-#include <memory>
 #include <string>
 #include <thread>
 #include <tuple>