Fixes related to clang-tidy

Author: lefticus

.clang-tidy

@@ -1,4 +1,7 @@
 ---
+
+# Unfortunately const-correctness seems to be almost completely broken
+# (clang 19)
 Checks: "*,
         -abseil-*,
         -altera-*,
@@ -11,13 +14,16 @@ Checks: "*,
         -readability-else-after-return,
         -readability-static-accessed-through-instance,
         -readability-avoid-const-params-in-decls,
+        -readability-simplify-boolean-expr,
         -cppcoreguidelines-non-private-member-variables-in-classes,
         -misc-non-private-member-variables-in-classes,
+        -misc-const-correctness,
 "
 WarningsAsErrors: ''
-HeaderFilterRegex: ''
+HeaderFilterRegex: '^(src|include)/.*'
 FormatStyle:     none
 
+
 # Command line options
 ExtraArgs: [
   '-Wno-unknown-warning-option',
@@ -31,6 +37,6 @@ ExtraArgs: [
 # It doesn't have a YAML equivalent
 
 CheckOptions:
-  readability-identifier-length.IgnoredVariableNames: 'x|y|z|id|ch'
-  readability-identifier-length.IgnoredParameterNames: 'x|y|z|id|ch'
+  readability-identifier-length.IgnoredVariableNames: 'x|y|z|id|ch|to'
+  readability-identifier-length.IgnoredParameterNames: 'x|y|z|id|ch|to'
 

CMakeLists.txt

@@ -26,6 +26,16 @@ include(cmake/PreventInSourceBuilds.cmake)
 include(cmake/Emscripten.cmake)
 include(ProjectOptions.cmake)
 
+if(MSVC)
+  
+elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+  add_compile_options(-fconstexpr-steps=12712420)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  
+else()
+  
+  # TODO support Intel compiler
+endif()
 
 cons_expr_setup_options()
 

cmake/StaticAnalyzers.cmake

@@ -77,6 +77,8 @@ macro(cons_expr_enable_clang_tidy target WARNINGS_AS_ERRORS)
         -extra-arg=-Wno-unused-command-line-argument
         -extra-arg=-Wno-unknown-argument
         -extra-arg=-Wno-gcc-compat
+        -extra-arg=-Wno-gcc-compat
+        -extra-arg=-fconstexpr-steps=12712420
         --quiet
         -p)
     # set standard

examples/compile_test.cpp

@@ -1,8 +1,13 @@
 #include <cons_expr/cons_expr.hpp>
+#include <cstdint>
+#include <cstdio>
 #include <format>
+#include <string_view>
+#include <functional>
 
 using cons_expr_type = lefticus::cons_expr<std::uint16_t, char, long long, long double>;
 
+namespace {
 constexpr long long add(long long x, long long y) { return x + y; }
 
 consteval auto make_scripted_function()
@@ -28,6 +33,7 @@ consteval auto make_scripted_function()
 
   return std::bind_front(evaluator.make_callable<long long(long long, long long)>("sum"), evaluator);
 }
+}
 
 
 int main()
@@ -40,7 +46,7 @@ int main()
     std::puts(std::format("sum({} to {}) = {}", from, to, func(from, to).value()).c_str());
   };
 
-  print_sum(101, 132414);
-  print_sum(1, 1222222);
-  print_sum(-10, 10);
+  print_sum(101, 132414); // NOLINT these values are arbitrary
+  print_sum(1, 1222222); // NOLINT
+  print_sum(-10, 10); // NOLINT
 }

examples/speed_test.cpp

@@ -1,9 +1,14 @@
 #include <cons_expr/cons_expr.hpp>
+#include <cstdint>
 #include <iostream>
+#include <string_view>
 
+
+
+namespace {
 constexpr long long add(long long x, long long y) { return x + y; }
 
-void display(long long i) { std::cout << i << '\n'; }
+void display(long long value) { std::cout << value << '\n'; }
 
 using cons_expr_type = lefticus::cons_expr<std::uint16_t, char, long long, double>;
 
@@ -21,6 +26,7 @@ template<typename Result> Result evaluate_to(std::string_view input)
 {
   return std::get<Result>(std::get<cons_expr_type::Atom>(evaluate(input).value));
 }
+}
 
 int main()
 {

fuzz_test/fuzz_tester.cpp

@@ -1,14 +1,13 @@
 #include <cons_expr/cons_expr.hpp>
-#include <cons_expr/utility.hpp>
-#include <fmt/format.h>
+#include <cstdint>
+#include <cstddef>
+#include <iterator>
 #include <string>
-#include <string_view>
 
 // Fuzzer that tests the cons_expr parser and evaluator
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-  // Create a string view from the fuzz data
-  std::string_view script(reinterpret_cast<const char *>(data), size);
+  const std::string script(data, std::next(data, static_cast<std::ptrdiff_t>(size)));
 
   // Initialize the cons_expr evaluator
   lefticus::cons_expr<> evaluator;
@@ -21,4 +20,4 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
   [[maybe_unused]] auto result = evaluator.sequence(evaluator.global_scope, parse_result);
 
   return 0;// Non-zero return values are reserved for future use
-}
+}

src/ccons_expr/main.cpp

@@ -1,19 +1,22 @@
+#include <cstddef>
+#include <exception>
 #include <format>
 #include <string>
 #include <vector>
 
-#include "ftxui/component/captured_mouse.hpp"// for ftxui
 #include "ftxui/component/component.hpp"// for Input, Renderer, ResizableSplitLeft
 #include "ftxui/component/component_base.hpp"// for ComponentBase, Component
 #include "ftxui/component/screen_interactive.hpp"// for ScreenInteractive
 #include "ftxui/dom/elements.hpp"// for operator|, separator, text, Element, flex, vbox, border
-#include "ftxui/dom/table.hpp"// for operator|, separator, text, Element, flex, vbox, border
 
 #include <cons_expr/cons_expr.hpp>
 #include <cons_expr/utility.hpp>
 
 #include <internal_use_only/config.hpp>
 
+static constexpr int InitialSplitWidth = 50;
+static constexpr int GlobalsHeight = 5;
+static constexpr int ValuesHeight = 7;
 
 int main([[maybe_unused]] int argc, [[maybe_unused]] const char *argv[])
 {
@@ -38,19 +41,19 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char *argv[])
 
   auto update_objects = [&]() {
     entries.clear();
-    for (std::size_t index = 0; auto item : evaluator.values[{ 0, evaluator.values.size() }]) {
+    for (std::size_t index = 0; auto item : evaluator.values[{ .start=0, .size=evaluator.values.size() }]) {
       entries.push_back(std::format("{}: {}", index, to_string(evaluator, true, item)));
       ++index;
     }
 
     characters.clear();
-    for (std::size_t index = 0; auto item : evaluator.strings[{ 0, evaluator.strings.size() }]) {
+    for (std::size_t index = 0; auto item : evaluator.strings[{ .start=0, .size=evaluator.strings.size() }]) {
       characters.push_back(std::format("{}: '{}'", index, item));
       ++index;
     }
 
     globals.clear();
-    for (auto [key, value] : evaluator.global_scope[{ 0, evaluator.global_scope.size() }]) {
+    for (auto [key, value] : evaluator.global_scope[{ .start=0, .size=evaluator.global_scope.size() }]) {
       globals.push_back(std::format("{}: '{}'", to_string(evaluator, false, key), to_string(evaluator, true, value)));
     }
   };
@@ -77,7 +80,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char *argv[])
 
 
   auto button = ftxui::Button("Evaluate", do_evaluate);
-  int size = 50;
+  int size = InitialSplitWidth;
   auto resizeable_bits = ftxui::ResizableSplitLeft(textarea_1, output_1, &size);
 
   auto radiobox = ftxui::Menu(&entries, &selected);
@@ -113,10 +116,10 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] const char *argv[])
     return ftxui::hbox({ characterbox->Render() | ftxui::vscroll_indicator | ftxui::frame,
              ftxui::separator(),
              ftxui::vbox({ globalsbox->Render() | ftxui::vscroll_indicator | ftxui::frame
-                             | ftxui::size(ftxui::HEIGHT, ftxui::EQUAL, 5),
+                             | ftxui::size(ftxui::HEIGHT, ftxui::EQUAL, GlobalsHeight),
                ftxui::separator(),
                radiobox->Render() | ftxui::vscroll_indicator | ftxui::frame
-                 | ftxui::size(ftxui::HEIGHT, ftxui::EQUAL, 7),
+                 | ftxui::size(ftxui::HEIGHT, ftxui::EQUAL, ValuesHeight),
                ftxui::separator(),
                resizeable_bits->Render() | ftxui::flex,
                ftxui::separator(),

src/cons_expr_cli/main.cpp

@@ -1,32 +1,43 @@
 #include <CLI/CLI.hpp>
+#include <cstdio>
+#include <cstdlib>
+#include <exception>
 #include <filesystem>
 #include <format>
 #include <fstream>
+#include <iostream>
+#include <ios>
+#include <optional>
+#include <ostream>
 #include <spdlog/spdlog.h>
 #include <sstream>
 
 #include <cons_expr/cons_expr.hpp>
 #include <cons_expr/utility.hpp>
 
 #include <internal_use_only/config.hpp>
+#include <string>
+#include <stdexcept>
 
 using cons_expr_type = lefticus::cons_expr<>;
 namespace fs = std::filesystem;
 
-void display(cons_expr_type::int_type i) { std::cout << i << '\n'; }
+namespace {
+void display(cons_expr_type::int_type value) { std::cout << value << '\n'; }
 
 // Read a file into a string
 std::string read_file(const fs::path &path)
 {
   if (!fs::exists(path)) { throw std::runtime_error(std::format("File not found: {}", path.string())); }
 
-  std::ifstream file(path, std::ios::in | std::ios::binary);
+  std::ifstream const file(path, std::ios::in | std::ios::binary);
   if (!file) { throw std::runtime_error(std::format("Failed to open file: {}", path.string())); }
 
   std::stringstream buffer;
   buffer << file.rdbuf();
   return buffer.str();
 }
+}
 
 int main(int argc, const char **argv)
 {
@@ -63,7 +74,7 @@ int main(int argc, const char **argv)
     if (file_path) {
       try {
         std::cout << "Executing script from file: " << *file_path << '\n';
-        std::string file_content = read_file(fs::path(*file_path));
+        std::string const file_content = read_file(fs::path(*file_path));
 
         auto [parse_result, remaining] = evaluator.parse(file_content);
         auto result = evaluator.sequence(evaluator.global_scope, parse_result);

test/cond_tests.cpp

@@ -1,13 +1,14 @@
 #include <catch2/catch_test_macros.hpp>
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
 
 #include <cons_expr/cons_expr.hpp>
-#include <cons_expr/utility.hpp>
-#include <internal_use_only/config.hpp>
+#include <cstdint>
+#include <string_view>
+#include <variant>
 
 using IntType = int;
 using FloatType = double;
 
+namespace {
 template<typename Result> constexpr Result evaluate_to(std::string_view input)
 {
   lefticus::cons_expr<std::uint16_t, char, IntType, FloatType> evaluator;
@@ -20,13 +21,15 @@ template<typename Result> constexpr bool evaluate_expected(std::string_view inpu
   return evaluator.evaluate_to<Result>(input).value() == result;
 }
 
+
 // Helper to check if an expression results in an error
 constexpr bool is_error(std::string_view input)
 {
   lefticus::cons_expr<std::uint16_t, char, IntType, FloatType> evaluator;
   auto result = evaluator.evaluate(input);
   return std::holds_alternative<lefticus::Error<std::uint16_t>>(result.value);
 }
+}
 
 TEST_CASE("Cond expression basic usage", "[cond]")
 {