From 636882316b5191931e144212d93665c10859ac95 Mon Sep 17 00:00:00 2001 From: Steven Le Rouzic Date: Fri, 7 Mar 2025 00:00:43 +0100 Subject: Some work on clang-tidy-ing things up --- asl/base/defer_tests.cpp | 10 +++--- asl/base/meta.hpp | 2 +- asl/containers/buffer.hpp | 9 +++--- asl/containers/buffer_tests.cpp | 24 +++++++------- asl/containers/hash_map_tests.cpp | 1 + asl/containers/hash_set.hpp | 7 ++-- asl/containers/hash_set_tests.cpp | 15 +++++---- asl/containers/intrusive_list.hpp | 2 +- asl/containers/intrusive_list_tests.cpp | 2 ++ asl/formatting/format.cpp | 4 +-- asl/formatting/format_float.cpp | 14 ++++---- asl/hashing/hash.hpp | 2 +- asl/hashing/hash_tests.cpp | 57 +++++++++++++++++---------------- asl/io/print.cpp | 2 +- asl/strings/string.hpp | 10 +++--- asl/strings/string_builder_tests.cpp | 4 +-- asl/strings/string_tests.cpp | 4 +-- asl/strings/string_view_tests.cpp | 16 ++++----- asl/types/box_tests.cpp | 2 +- asl/types/option_tests.cpp | 18 +++++------ asl/types/span_tests.cpp | 42 ++++++++++++------------ asl/types/status.cpp | 6 ++++ asl/types/status_or_tests.cpp | 14 ++++---- asl/types/status_tests.cpp | 12 +++---- 24 files changed, 145 insertions(+), 134 deletions(-) (limited to 'asl') diff --git a/asl/base/defer_tests.cpp b/asl/base/defer_tests.cpp index 4c53f2c..097a6a8 100644 --- a/asl/base/defer_tests.cpp +++ b/asl/base/defer_tests.cpp @@ -10,25 +10,25 @@ ASL_TEST(defer) uint32_t a = 0; { - ASL_DEFER [&a]() { a |= 1; }; + ASL_DEFER [&a]() { a |= 1U; }; ASL_TEST_EXPECT(a == 0); { - ASL_DEFER [&a]() { a |= 2; }; - ASL_DEFER [&a]() { a |= 4; }; + ASL_DEFER [&a]() { a |= 2U; }; + ASL_DEFER [&a]() { a |= 4U; }; ASL_TEST_EXPECT(a == 0); } ASL_TEST_EXPECT(a == 6); { - ASL_DEFER [&a]() { a |= 8; }; + ASL_DEFER [&a]() { a |= 8U; }; ASL_TEST_EXPECT(a == 6); } ASL_TEST_EXPECT(a == 14); - ASL_DEFER [&a]() { a |= 16; }; + ASL_DEFER [&a]() { a |= 16U; }; ASL_TEST_EXPECT(a == 14); } diff --git a/asl/base/meta.hpp b/asl/base/meta.hpp index b798eeb..06c7c59 100644 --- a/asl/base/meta.hpp +++ b/asl/base/meta.hpp @@ -153,7 +153,7 @@ template struct _tame_helper { using type = T; }; #define TAME_HELPER_IMPL(TRAILING) \ template \ - struct _tame_helper { using type = R(Args...); } + struct _tame_helper { using type = R(Args...); } // NOLINT(*-parentheses) TAME_HELPER_IMPL(); TAME_HELPER_IMPL(&); diff --git a/asl/containers/buffer.hpp b/asl/containers/buffer.hpp index 386b52a..c7fc01f 100644 --- a/asl/containers/buffer.hpp +++ b/asl/containers/buffer.hpp @@ -80,7 +80,7 @@ private: { return is_on_heap(size_encoded) ? static_cast(size_encoded & (~kOnHeapMask)) - : static_cast(size_encoded >> 56); + : static_cast(size_encoded >> 56U); } } @@ -110,7 +110,7 @@ private: constexpr void set_size_inline(isize_t new_size) { ASL_ASSERT(new_size >= 0 && new_size <= kInlineCapacity); - size_t size_encoded = (load_size_encoded() & size_t{0x00ff'ffff'ffff'ffff}) | (bit_cast(new_size) << 56); + size_t size_encoded = (load_size_encoded() & size_t{0x00ff'ffff'ffff'ffff}) | (bit_cast(new_size) << 56U); store_size_encoded(size_encoded); } @@ -328,12 +328,12 @@ public: if (currently_on_heap && trivially_move_constructible) { - m_data = reinterpret_cast(m_allocator.realloc(m_data, old_layout, new_layout)); + m_data = static_cast(m_allocator.realloc(m_data, old_layout, new_layout)); m_capacity = new_capacity; return; } - T* new_data = reinterpret_cast(m_allocator.alloc(new_layout)); + T* new_data = static_cast(m_allocator.alloc(new_layout)); relocate_uninit_n(new_data, old_data, current_size); @@ -394,6 +394,7 @@ public: } else { + // NOLINTNEXTLINE(*-reinterpret-cast) return self.is_on_heap() ? return_type{ self.m_data } : reinterpret_cast(&self); } } diff --git a/asl/containers/buffer_tests.cpp b/asl/containers/buffer_tests.cpp index af79c92..2538e92 100644 --- a/asl/containers/buffer_tests.cpp +++ b/asl/containers/buffer_tests.cpp @@ -24,7 +24,7 @@ ASL_TEST(default_size) ASL_TEST_EXPECT(b1.capacity() == 5); ASL_TEST_EXPECT(static_cast(b1.data()) == &b1); - asl::buffer b2; + const asl::buffer b2; ASL_TEST_EXPECT(b2.size() == 0); ASL_TEST_EXPECT(b2.capacity() == 0); ASL_TEST_EXPECT(b2.data() == nullptr); @@ -34,6 +34,7 @@ struct CounterAllocator { isize_t* count; + [[nodiscard]] void* alloc(const asl::layout& layout) const { *count += 1; @@ -76,6 +77,7 @@ struct IncompatibleAllocator }; static_assert(asl::allocator); +// NOLINTNEXTLINE(*-complexity) ASL_TEST(reserve_capacity) { isize_t count = 0; @@ -105,6 +107,7 @@ ASL_TEST(reserve_capacity) ASL_TEST_EXPECT(count == 2); } +// NOLINTNEXTLINE(*-complexity) ASL_TEST(push) { asl::buffer b; @@ -137,7 +140,7 @@ ASL_TEST(push) ASL_TEST(from_span) { - int data[] = {1, 2, 4, 8}; + const int data[] = {1, 2, 4, 8}; asl::buffer b{data}; ASL_TEST_EXPECT(b.size() == 4); @@ -157,12 +160,14 @@ struct MoveableType MoveableType(MoveableType&& other) : moved{other.moved + 1}, value{other.value} {} MoveableType& operator=(const MoveableType&) = delete; MoveableType& operator=(MoveableType&&) = delete; + ~MoveableType() = default; }; static_assert(!asl::trivially_copy_constructible); static_assert(!asl::trivially_move_constructible); static_assert(!asl::copyable); static_assert(asl::move_constructible); +// NOLINTNEXTLINE(*-complexity) ASL_TEST(push_move) { asl::buffer b; @@ -275,14 +280,13 @@ ASL_TEST(move_construct_from_heap) buf.push(&d[2]); { - asl::buffer buf2(std::move(buf)); + const asl::buffer buf2(std::move(buf)); ASL_TEST_EXPECT(buf2.size() == 3); ASL_TEST_EXPECT(d[0] == false); ASL_TEST_EXPECT(d[1] == false); ASL_TEST_EXPECT(d[2] == false); } - ASL_TEST_EXPECT(buf.size() == 0); ASL_TEST_EXPECT(d[0] == true); ASL_TEST_EXPECT(d[1] == true); ASL_TEST_EXPECT(d[2] == true); @@ -299,7 +303,6 @@ ASL_TEST(move_construct_inline_trivial) ASL_TEST_EXPECT(buf2[1] == 2U); ASL_TEST_EXPECT(buf2.size() == 2); - ASL_TEST_EXPECT(buf.size() == 0); } ASL_TEST(move_construct_from_inline_non_trivial) @@ -310,17 +313,17 @@ ASL_TEST(move_construct_from_inline_non_trivial) buf.push(&d[1]); { - asl::buffer buf2(std::move(buf)); + const asl::buffer buf2(std::move(buf)); ASL_TEST_EXPECT(buf2.size() == 2); ASL_TEST_EXPECT(d[0] == false); ASL_TEST_EXPECT(d[1] == false); } - ASL_TEST_EXPECT(buf.size() == 0); ASL_TEST_EXPECT(d[0] == true); ASL_TEST_EXPECT(d[1] == true); } +// NOLINTNEXTLINE(*-complexity) ASL_TEST(move_assign_from_heap) { bool d[6]{}; @@ -346,7 +349,6 @@ ASL_TEST(move_assign_from_heap) buf2 = std::move(buf); - ASL_TEST_EXPECT(buf.size() == 0); ASL_TEST_EXPECT(buf2.size() == 3); ASL_TEST_EXPECT(d[0] == false); @@ -384,7 +386,6 @@ ASL_TEST(move_assign_trivial_heap_to_inline) ASL_TEST_EXPECT(alloc_count == 1); ASL_TEST_EXPECT(buf.size() == 3); - ASL_TEST_EXPECT(buf2.size() == 0); ASL_TEST_EXPECT(buf[0] == 3); ASL_TEST_EXPECT(buf[1] == 4); ASL_TEST_EXPECT(buf[2] == 5); @@ -408,12 +409,12 @@ ASL_TEST(move_assign_trivial_inline_to_heap) buf2 = std::move(buf); ASL_TEST_EXPECT(alloc_count == 1); - ASL_TEST_EXPECT(buf.size() == 0); ASL_TEST_EXPECT(buf2.size() == 2); ASL_TEST_EXPECT(buf2[0] == 1); ASL_TEST_EXPECT(buf2[1] == 2); } +// NOLINTNEXTLINE(*-complexity) ASL_TEST(move_assign_inline_to_heap) { bool d[6]{}; @@ -432,7 +433,6 @@ ASL_TEST(move_assign_inline_to_heap) buf2 = std::move(buf); - ASL_TEST_EXPECT(buf.size() == 0); ASL_TEST_EXPECT(buf2.size() == 2); ASL_TEST_EXPECT(d[0] == false); ASL_TEST_EXPECT(d[1] == false); @@ -450,6 +450,7 @@ ASL_TEST(move_assign_inline_to_heap) ASL_TEST_EXPECT(d[5] == true); } +// NOLINTNEXTLINE(*-complexity) ASL_TEST(move_assign_from_inline_incompatible_allocator) { bool d[6]{}; @@ -468,7 +469,6 @@ ASL_TEST(move_assign_from_inline_incompatible_allocator) buf2 = std::move(buf); - ASL_TEST_EXPECT(buf.size() == 0); ASL_TEST_EXPECT(buf2.size() == 2); ASL_TEST_EXPECT(d[0] == false); ASL_TEST_EXPECT(d[1] == false); diff --git a/asl/containers/hash_map_tests.cpp b/asl/containers/hash_map_tests.cpp index 9652e2f..fe8a284 100644 --- a/asl/containers/hash_map_tests.cpp +++ b/asl/containers/hash_map_tests.cpp @@ -5,6 +5,7 @@ #include "asl/testing/testing.hpp" #include "asl/containers/hash_map.hpp" +// NOLINTNEXTLINE(*-complexity) ASL_TEST(default) { asl::hash_map map; diff --git a/asl/containers/hash_set.hpp b/asl/containers/hash_set.hpp index 61346fa..02a8036 100644 --- a/asl/containers/hash_set.hpp +++ b/asl/containers/hash_set.hpp @@ -75,7 +75,7 @@ protected: constexpr isize_t max_size() const { // Max load factor is 75% - return (m_capacity >> 1) + (m_capacity >> 2); + return (m_capacity >> 1) + (m_capacity >> 2); // NOLINT(*-signed-bitwise) } static isize_t size_to_capacity(isize_t size) @@ -131,8 +131,8 @@ protected: { ASL_ASSERT(new_capacity >= kMinCapacity && is_pow2(new_capacity) && new_capacity > m_capacity); - auto* new_tags = reinterpret_cast(m_allocator.alloc(layout::array(new_capacity))); - auto* new_values = reinterpret_cast*>(m_allocator.alloc(layout::array>(new_capacity))); + auto* new_tags = static_cast(m_allocator.alloc(layout::array(new_capacity))); + auto* new_values = static_cast*>(m_allocator.alloc(layout::array>(new_capacity))); asl::memzero(new_tags, new_capacity); isize_t new_size = 0; @@ -228,7 +228,6 @@ protected: result.tag = static_cast(hash & kHashMask) | kHasValue; // NOLINTBEGIN(*-pointer-arithmetic) - for ( isize_t i = starting_index; i != starting_index || result.first_available_index < 0; diff --git a/asl/containers/hash_set_tests.cpp b/asl/containers/hash_set_tests.cpp index 515fe76..8f42e50 100644 --- a/asl/containers/hash_set_tests.cpp +++ b/asl/containers/hash_set_tests.cpp @@ -10,7 +10,7 @@ ASL_TEST(empty) { - asl::hash_set set; + const asl::hash_set set; ASL_TEST_EXPECT(set.size() == 0); @@ -42,7 +42,7 @@ ASL_TEST(a_bunch_of_ints) { asl::hash_set set; - int count = 3000; + const int count = 3000; for (int i = 0; i < count; ++i) { @@ -98,6 +98,7 @@ struct CustomHasher } }; +// NOLINTNEXTLINE(*-complexity) ASL_TEST(destructor_and_remove) { static constexpr int kCount = 200; @@ -113,9 +114,9 @@ ASL_TEST(destructor_and_remove) ASL_TEST_EXPECT(set.size() == kCount); - for (int i = 0; i < kCount; ++i) + for (const bool i : destroyed) { - ASL_TEST_EXPECT(!destroyed[i]); // NOLINT + ASL_TEST_EXPECT(!i); // NOLINT } for (int i = 0; i < kCount; i += 2) @@ -132,9 +133,9 @@ ASL_TEST(destructor_and_remove) } } - for (int i = 0; i < kCount; ++i) + for (const bool i : destroyed) { - ASL_TEST_EXPECT(destroyed[i]); // NOLINT + ASL_TEST_EXPECT(i); // NOLINT } } @@ -147,7 +148,7 @@ ASL_TEST(copy) set1.insert(i); } - asl::hash_set set2 = set1; + const asl::hash_set set2 = set1; asl::hash_set set3; set3 = set1; diff --git a/asl/containers/intrusive_list.hpp b/asl/containers/intrusive_list.hpp index 2af02eb..a58bbfd 100644 --- a/asl/containers/intrusive_list.hpp +++ b/asl/containers/intrusive_list.hpp @@ -188,5 +188,5 @@ public: } }; -} +} // namespace asl diff --git a/asl/containers/intrusive_list_tests.cpp b/asl/containers/intrusive_list_tests.cpp index 4e19237..146ab6b 100644 --- a/asl/containers/intrusive_list_tests.cpp +++ b/asl/containers/intrusive_list_tests.cpp @@ -23,6 +23,7 @@ ASL_TEST(empty_list) ASL_TEST_EXPECT(list.back() == nullptr); } +// NOLINTNEXTLINE(*-complexity) ASL_TEST(push_front) { IntNode one{1}; @@ -75,6 +76,7 @@ ASL_TEST(push_front) ASL_TEST_ASSERT(it == end); } +// NOLINTNEXTLINE(*-complexity) ASL_TEST(push_back) { IntNode one{1}; diff --git a/asl/formatting/format.cpp b/asl/formatting/format.cpp index 4f35a52..732d89f 100644 --- a/asl/formatting/format.cpp +++ b/asl/formatting/format.cpp @@ -151,7 +151,7 @@ asl::string_view asl::format_uint64(uint64_t v, asl::span= 100) { - uint64_t x = v % 100; + const uint64_t x = v % 100; v /= 100; write_two(s_pairs.subspan(static_cast(x * 2)).first<2>()); } @@ -195,7 +195,7 @@ void asl::AslFormat(Formatter& f, int64_t v) if (v < 0) { f.write("-"); - uint64_t absolute_value = ~(bit_cast(v) - 1); + const uint64_t absolute_value = ~(bit_cast(v) - 1); AslFormat(f, absolute_value); } else diff --git a/asl/formatting/format_float.cpp b/asl/formatting/format_float.cpp index aa113c6..3802ff9 100644 --- a/asl/formatting/format_float.cpp +++ b/asl/formatting/format_float.cpp @@ -25,12 +25,12 @@ static constexpr char kZeros[kZeroCount] = { static constexpr bool is_zero(float x) { - return (asl::bit_cast(x) & 0x7fff'ffff) == 0; + return (asl::bit_cast(x) & 0x7fff'ffffU) == 0; } static constexpr bool is_zero(double x) { - return (asl::bit_cast(x) & 0x7fff'ffff'ffff'ffff) == 0; + return (asl::bit_cast(x) & 0x7fff'ffff'ffff'ffffULL) == 0; } template @@ -66,15 +66,15 @@ static void format_float(asl::Formatter& f, T value) if (decimal.is_negative) { f.write("-"); } char buffer[20]; - asl::string_view digits = asl::format_uint64(decimal.significand, buffer); + const asl::string_view digits = asl::format_uint64(decimal.significand, buffer); if (decimal.exponent >= 0) { f.write(digits); while (decimal.exponent > 0) { - isize_t to_write = asl::min(static_cast(decimal.exponent), kZeroCount); - f.write(asl::string_view(kZeros, to_write)); + const isize_t to_write = asl::min(static_cast(decimal.exponent), kZeroCount); + f.write(asl::string_view(static_cast(kZeros), to_write)); decimal.exponent -= to_write; } } @@ -86,8 +86,8 @@ static void format_float(asl::Formatter& f, T value) decimal.exponent = -decimal.exponent - static_cast(digits.size()); while (decimal.exponent > 0) { - isize_t to_write = asl::min(static_cast(decimal.exponent), kZeroCount); - f.write(asl::string_view(kZeros, to_write)); + const isize_t to_write = asl::min(static_cast(decimal.exponent), kZeroCount); + f.write(asl::string_view(static_cast(kZeros), to_write)); decimal.exponent -= to_write; } f.write(digits); diff --git a/asl/hashing/hash.hpp b/asl/hashing/hash.hpp index 443a774..f8987df 100644 --- a/asl/hashing/hash.hpp +++ b/asl/hashing/hash.hpp @@ -80,7 +80,7 @@ struct HashState { auto bytes = as_bytes(s); auto hashed = city_hash::CityHash128WithSeed( - reinterpret_cast(bytes.data()), + reinterpret_cast(bytes.data()), // NOLINT(*-reinterpret-cast) static_cast(bytes.size()), h.state); return HashState{hashed}; diff --git a/asl/hashing/hash_tests.cpp b/asl/hashing/hash_tests.cpp index e4e69bf..4cb2f6e 100644 --- a/asl/hashing/hash_tests.cpp +++ b/asl/hashing/hash_tests.cpp @@ -29,10 +29,10 @@ static_assert(asl::hashable); ASL_TEST(integers) { - uint64_t a = asl::hash_value(45); - uint64_t b = asl::hash_value(45); - uint64_t c = asl::hash_value(46); - uint64_t d = asl::hash_value(45); + const uint64_t a = asl::hash_value(45); + const uint64_t b = asl::hash_value(45); + const uint64_t c = asl::hash_value(46); + const uint64_t d = asl::hash_value(45); ASL_TEST_EXPECT(a == b); ASL_TEST_EXPECT(a != c); @@ -187,19 +187,19 @@ static_assert(asl::uniquely_represented>); ASL_TEST(option) { - asl::option int1 = 0; - asl::option int2 = 0; - asl::option int3 = 1; - asl::option int4 = asl::nullopt; + const asl::option int1 = 0; + const asl::option int2 = 0; + const asl::option int3 = 1; + const asl::option int4 = asl::nullopt; ASL_TEST_EXPECT(asl::hash_value(int1) == asl::hash_value(int2)); ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int3)); ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int4)); - asl::option noz1{8}; - asl::option noz2{8}; - asl::option noz3{9}; - asl::option noz4 = asl::nullopt; + const asl::option noz1{8}; + const asl::option noz2{8}; + const asl::option noz3{9}; + const asl::option noz4 = asl::nullopt; ASL_TEST_EXPECT(asl::hash_value(noz1) == asl::hash_value(noz2)); ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz3)); @@ -208,17 +208,18 @@ ASL_TEST(option) static_assert(asl::hashable); +// NOLINTNEXTLINE(*-cognitive-complexity) ASL_TEST(status) { - asl::status s1 = asl::ok(); - asl::status s2 = asl::ok(); - asl::status s3 = asl::internal_error(); - asl::status s4 = asl::internal_error(); - asl::status s5 = asl::runtime_error(); - asl::status s6 = asl::internal_error("Oh, no!"); - asl::status s7 = asl::internal_error("Oh, no!"); - asl::status s8 = asl::internal_error("Oh, no"); - asl::status s9 = asl::runtime_error("Oh, no!"); + const asl::status s1 = asl::ok(); + const asl::status s2 = asl::ok(); + const asl::status s3 = asl::internal_error(); + const asl::status s4 = asl::internal_error(); + const asl::status s5 = asl::runtime_error(); + const asl::status s6 = asl::internal_error("Oh, no!"); + const asl::status s7 = asl::internal_error("Oh, no!"); + const asl::status s8 = asl::internal_error("Oh, no"); + const asl::status s9 = asl::runtime_error("Oh, no!"); ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2)); ASL_TEST_EXPECT(asl::hash_value(s3) == asl::hash_value(s4)); @@ -244,13 +245,13 @@ static_assert(!asl::hashable>); ASL_TEST(status_or) { - asl::status_or s1 = 42; - asl::status_or s2 = 42; - asl::status_or s3 = 43; - asl::status_or s4 = asl::runtime_error(); - asl::status_or s5 = asl::runtime_error(); - asl::status_or s6 = asl::runtime_error("Hello"); - asl::status_or s7 = asl::runtime_error("Hello"); + const asl::status_or s1 = 42; + const asl::status_or s2 = 42; + const asl::status_or s3 = 43; + const asl::status_or s4 = asl::runtime_error(); + const asl::status_or s5 = asl::runtime_error(); + const asl::status_or s6 = asl::runtime_error("Hello"); + const asl::status_or s7 = asl::runtime_error("Hello"); ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2)); ASL_TEST_EXPECT(asl::hash_value(s4) == asl::hash_value(s5)); diff --git a/asl/io/print.cpp b/asl/io/print.cpp index 5b48eef..173b3f7 100644 --- a/asl/io/print.cpp +++ b/asl/io/print.cpp @@ -18,7 +18,7 @@ public: void write(asl::span s) override { - fwrite(s.data(), 1, static_cast(s.size()), m_handle); + (void)fwrite(s.data(), 1, static_cast(s.size()), m_handle); } }; diff --git a/asl/strings/string.hpp b/asl/strings/string.hpp index 0f70228..7254762 100644 --- a/asl/strings/string.hpp +++ b/asl/strings/string.hpp @@ -26,7 +26,7 @@ public: constexpr string() requires default_constructible = default; explicit constexpr string(Allocator allocator) : m_buffer{std::move(allocator)} {} - // NOLINTNEXTLINE(*-explicit-conversions) + // NOLINTNEXTLINE(*explicit*) constexpr string(string_view sv) requires default_constructible : m_buffer{sv.as_span()} @@ -44,16 +44,16 @@ public: constexpr string& operator=(const string&) requires copy_assignable = default; constexpr string& operator=(string&&) = default; - constexpr isize_t size() const { return m_buffer.size(); } - constexpr const char* data() const { return m_buffer.data(); } + [[nodiscard]] constexpr isize_t size() const { return m_buffer.size(); } + [[nodiscard]] constexpr const char* data() const { return m_buffer.data(); } - // NOLINTNEXTLINE(*-explicit-conversions) + // NOLINTNEXTLINE(*explicit*) constexpr operator string_view() const { return as_string_view(); } - constexpr string_view as_string_view() const + [[nodiscard]] constexpr string_view as_string_view() const { auto span = m_buffer.as_span(); return string_view{span.data(), span.size()}; diff --git a/asl/strings/string_builder_tests.cpp b/asl/strings/string_builder_tests.cpp index dadfc88..ac7a3da 100644 --- a/asl/strings/string_builder_tests.cpp +++ b/asl/strings/string_builder_tests.cpp @@ -14,13 +14,13 @@ ASL_TEST(string_builder) ASL_TEST_EXPECT(b.as_string_view() == "abcdefg"); - asl::string s = b.as_string(); + const asl::string s = b.as_string(); ASL_TEST_EXPECT(s == "abcdefg"); } ASL_TEST(string_builder_rvalue) { - asl::string s = asl::StringBuilder{}.push('a').push("bcdef").push('g').finish(); + const asl::string s = asl::StringBuilder{}.push('a').push("bcdef").push('g').finish(); ASL_TEST_EXPECT(s == "abcdefg"); } diff --git a/asl/strings/string_tests.cpp b/asl/strings/string_tests.cpp index 4ef6185..90d1dbb 100644 --- a/asl/strings/string_tests.cpp +++ b/asl/strings/string_tests.cpp @@ -8,7 +8,7 @@ ASL_TEST(default) { - asl::string s; + const asl::string s; ASL_TEST_ASSERT(s.size() == 0); ASL_TEST_ASSERT(s.as_string_view().size() == 0); ASL_TEST_ASSERT(s == ""_sv); @@ -17,7 +17,7 @@ ASL_TEST(default) ASL_TEST(from_string_view) { - asl::string s = "hello"_sv; + const asl::string s = "hello"_sv; ASL_TEST_ASSERT(s.size() == 5); ASL_TEST_ASSERT(s == "hello"_sv); } diff --git a/asl/strings/string_view_tests.cpp b/asl/strings/string_view_tests.cpp index 33a8d71..b77c4ff 100644 --- a/asl/strings/string_view_tests.cpp +++ b/asl/strings/string_view_tests.cpp @@ -10,20 +10,20 @@ static_assert(asl::trivially_copy_constructible); ASL_TEST(default) { - asl::string_view s1; + const asl::string_view s1; ASL_TEST_EXPECT(s1.is_empty()); - asl::string_view s2 = nullptr; + const asl::string_view s2 = nullptr; ASL_TEST_EXPECT(s2.is_empty()); } ASL_TEST(from_literal) { - asl::string_view s1 = "Hello"_sv; + const asl::string_view s1 = "Hello"_sv; ASL_TEST_ASSERT(s1.size() == 5); ASL_TEST_EXPECT(asl::memcmp(s1.data(), "Hello", 5) == 0); - asl::string_view s2 = ""_sv; + const asl::string_view s2 = ""_sv; ASL_TEST_EXPECT(s2.is_empty()); } @@ -47,7 +47,7 @@ ASL_TEST(from_zstr) ASL_TEST(substr1) { - asl::string_view s1 = "abcd"; + const asl::string_view s1 = "abcd"; asl::string_view s2 = s1.substr(0); ASL_TEST_ASSERT(s2.size() == 4); @@ -63,7 +63,7 @@ ASL_TEST(substr1) ASL_TEST(substr2) { - asl::string_view s1 = "abcd"; + const asl::string_view s1 = "abcd"; asl::string_view s2 = s1.substr(0, 4); ASL_TEST_ASSERT(s2.size() == 4); @@ -82,7 +82,7 @@ ASL_TEST(substr2) ASL_TEST(first) { - asl::string_view s1 = "abcd"; + const asl::string_view s1 = "abcd"; asl::string_view s2 = s1.first(0); ASL_TEST_ASSERT(s2.size() == 0); @@ -98,7 +98,7 @@ ASL_TEST(first) ASL_TEST(last) { - asl::string_view s1 = "abcd"; + const asl::string_view s1 = "abcd"; asl::string_view s2 = s1.last(0); ASL_TEST_ASSERT(s2.size() == 0); diff --git a/asl/types/box_tests.cpp b/asl/types/box_tests.cpp index d7281ed..b3c55b2 100644 --- a/asl/types/box_tests.cpp +++ b/asl/types/box_tests.cpp @@ -81,7 +81,7 @@ ASL_TEST(niche) ASL_TEST_EXPECT(destroyed); } -class Base +class Base // NOLINT { public: virtual ~Base() = default; diff --git a/asl/types/option_tests.cpp b/asl/types/option_tests.cpp index 2dff6f5..d08c94a 100644 --- a/asl/types/option_tests.cpp +++ b/asl/types/option_tests.cpp @@ -99,8 +99,8 @@ static_assert(!asl::trivially_move_assignable>); ASL_TEST(make_null) { - asl::option a; - asl::option b = asl::nullopt; + const asl::option a; + const asl::option b = asl::nullopt; ASL_TEST_EXPECT(!a.has_value()); ASL_TEST_EXPECT(!b.has_value()); @@ -108,7 +108,7 @@ ASL_TEST(make_null) ASL_TEST(make_value) { - asl::option a = 48; + const asl::option a = 48; ASL_TEST_EXPECT(a.has_value()); } @@ -132,7 +132,7 @@ ASL_TEST(call_destructor) asl::option opt(std::move(obs)); ASL_TEST_EXPECT(!destroyed); - asl::option opt2 = std::move(opt); + const asl::option opt2 = std::move(opt); ASL_TEST_EXPECT(!destroyed); } @@ -213,7 +213,7 @@ ASL_TEST(convert_move) ASL_TEST_ASSERT(opt16.has_value()); ASL_TEST_EXPECT(opt16.value() == 8); - opt8 = std::move(uint8_t{10}); + opt8 = uint8_t{10}; ASL_TEST_ASSERT(opt8.has_value()); ASL_TEST_EXPECT(opt8.value() == 10); @@ -227,8 +227,8 @@ ASL_TEST(convert_move) ASL_TEST(value_or) { - asl::option a = asl::nullopt; - asl::option b = 2; + const asl::option a = asl::nullopt; + const asl::option b = 2; ASL_TEST_EXPECT(a.value_or(5) == 5); ASL_TEST_EXPECT(b.value_or(5) == 2); @@ -296,8 +296,8 @@ ASL_TEST(transform) ASL_TEST(or_else) { - asl::option a = 5; - asl::option b; + const asl::option a = 5; + const asl::option b; auto fn = []() -> asl::option { return 12; }; diff --git a/asl/types/span_tests.cpp b/asl/types/span_tests.cpp index 47749cf..55471ab 100644 --- a/asl/types/span_tests.cpp +++ b/asl/types/span_tests.cpp @@ -17,7 +17,7 @@ static_assert(asl::size_of> == asl::size_of); ASL_TEST(empty_dynamic) { - asl::span s; + const asl::span s; ASL_TEST_EXPECT(s.size() == 0); ASL_TEST_EXPECT(s.size_bytes() == 0); ASL_TEST_EXPECT(s.is_empty()); @@ -26,7 +26,7 @@ ASL_TEST(empty_dynamic) ASL_TEST(empty_static) { - asl::span s; + const asl::span s; ASL_TEST_EXPECT(s.size() == 0); ASL_TEST_EXPECT(s.size_bytes() == 0); ASL_TEST_EXPECT(s.is_empty()); @@ -35,7 +35,7 @@ ASL_TEST(empty_static) ASL_TEST(from_array_dynamic) { int array[] = {1, 2, 3}; - asl::span span = array; + const asl::span span = array; ASL_TEST_ASSERT(span.size() == 3); ASL_TEST_EXPECT(span[0] == 1); ASL_TEST_EXPECT(span[1] == 2); @@ -56,7 +56,7 @@ static_assert(!asl::constructible_from, int32_t(&)[10]>); ASL_TEST(from_array_static) { int array[] = {1, 2, 3}; - asl::span span = array; + const asl::span span = array; ASL_TEST_ASSERT(span.size() == 3); ASL_TEST_EXPECT(span[0] == 1); ASL_TEST_EXPECT(span[1] == 2); @@ -77,21 +77,21 @@ ASL_TEST(conversion) { int array[] = {1, 2, 3}; - asl::span span1 = array; + const asl::span span1 = array; - asl::span span2{span1}; + const asl::span span2{span1}; ASL_TEST_ASSERT(span2.size() == 3); ASL_TEST_EXPECT(span2[0] == 1); ASL_TEST_EXPECT(span2[1] == 2); ASL_TEST_EXPECT(span2[2] == 3); - asl::span span3 = span2; + const asl::span span3 = span2; ASL_TEST_ASSERT(span3.size() == 3); ASL_TEST_EXPECT(span3[0] == 1); ASL_TEST_EXPECT(span3[1] == 2); ASL_TEST_EXPECT(span3[2] == 3); - asl::span span4{span2}; + const asl::span span4{span2}; ASL_TEST_ASSERT(span4.size() == 3); ASL_TEST_EXPECT(span4[0] == 1); ASL_TEST_EXPECT(span4[1] == 2); @@ -138,7 +138,7 @@ static_assert(!IsValidSubspan, 2, 3>); ASL_TEST(subspan_static_from_static) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.subspan<0>(); ASL_TEST_ASSERT(s1.size() == 4); @@ -164,7 +164,7 @@ ASL_TEST(subspan_static_from_static) ASL_TEST(subspan_static_from_dynamic) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.subspan<0>(); ASL_TEST_ASSERT(s1.size() == 4); @@ -190,7 +190,7 @@ ASL_TEST(subspan_static_from_dynamic) ASL_TEST(subspan_dynamic) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.subspan(0); ASL_TEST_ASSERT(s1.size() == 4); @@ -249,7 +249,7 @@ static_assert(!IsValidFirst, asl::dynamic_size>); ASL_TEST(first_static_from_static) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.first<0>(); ASL_TEST_ASSERT(s1.size() == 0); @@ -270,7 +270,7 @@ ASL_TEST(first_static_from_static) ASL_TEST(first_static_from_dynamic) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.first<0>(); ASL_TEST_ASSERT(s1.size() == 0); @@ -291,7 +291,7 @@ ASL_TEST(first_static_from_dynamic) ASL_TEST(first_dynamic) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.first(0); ASL_TEST_ASSERT(s1.size() == 0); @@ -345,7 +345,7 @@ static_assert(!IsValidLast, asl::dynamic_size>); ASL_TEST(last_static_from_static) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.last<0>(); ASL_TEST_ASSERT(s1.size() == 0); @@ -366,7 +366,7 @@ ASL_TEST(last_static_from_static) ASL_TEST(last_static_from_dynamic) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.last<0>(); ASL_TEST_ASSERT(s1.size() == 0); @@ -387,7 +387,7 @@ ASL_TEST(last_static_from_dynamic) ASL_TEST(last_dynamic) { int array[] = {1, 2, 3, 4}; - asl::span span{array}; + const asl::span span{array}; auto s1 = span.last(0); ASL_TEST_ASSERT(s1.size() == 0); @@ -416,8 +416,8 @@ static_assert(HasAsMutableBytes); ASL_TEST(as_bytes) { uint32_t data[] = {0x01020304, 0x05060708}; - asl::span s1(data); - asl::span s2 = asl::as_bytes(s1); + const asl::span s1(data); + const asl::span s2 = asl::as_bytes(s1); ASL_TEST_ASSERT(s2.size() == 8); ASL_TEST_ASSERT(static_cast(s2[0]) == 0x04); @@ -433,8 +433,8 @@ ASL_TEST(as_bytes) ASL_TEST(as_mutable_bytes) { uint32_t data[] = {0x01020304, 0x05060708}; - asl::span s1(data); - asl::span s2 = asl::as_mutable_bytes(s1); + const asl::span s1(data); + const asl::span s2 = asl::as_mutable_bytes(s1); ASL_TEST_ASSERT(s2.size() == 8); ASL_TEST_ASSERT(static_cast(s2[0]) == 0x04); diff --git a/asl/types/status.cpp b/asl/types/status.cpp index 94c4977..43f3b9e 100644 --- a/asl/types/status.cpp +++ b/asl/types/status.cpp @@ -11,6 +11,8 @@ // @Todo Use custom allocator using Allocator = asl::DefaultAllocator; + +// NOLINTNEXTLINE(*-non-const-global-variables) static Allocator g_allocator{}; namespace @@ -47,18 +49,21 @@ asl::status::status(status_code code, string_view fmt, span(m_payload)->code; } asl::string_view asl::status::message_internal() const { ASL_ASSERT(!is_inline()); + // NOLINTNEXTLINE(*-reinterpret-cast) return reinterpret_cast(m_payload)->msg; } void asl::status::ref() { ASL_ASSERT(!is_inline()); + // NOLINTNEXTLINE(*-reinterpret-cast) auto* internal = reinterpret_cast(m_payload); atomic_fetch_increment(&internal->ref_count, memory_order::relaxed); } @@ -66,6 +71,7 @@ void asl::status::ref() void asl::status::unref() { ASL_ASSERT(!is_inline()); + // NOLINTNEXTLINE(*-reinterpret-cast) auto* internal = reinterpret_cast(m_payload); if (atomic_fetch_decrement(&internal->ref_count, memory_order::release) == 1) { diff --git a/asl/types/status_or_tests.cpp b/asl/types/status_or_tests.cpp index 08b4a0f..1a96c80 100644 --- a/asl/types/status_or_tests.cpp +++ b/asl/types/status_or_tests.cpp @@ -20,24 +20,24 @@ static_assert(!asl::moveable>); ASL_TEST(ok) { - asl::status_or s = 6; + const asl::status_or s = 6; ASL_TEST_EXPECT(s.ok()); ASL_TEST_EXPECT(s.code() == asl::status_code::ok); } ASL_TEST(from_status) { - asl::status_or s = asl::internal_error(); + const asl::status_or s = asl::internal_error(); ASL_TEST_EXPECT(!s.ok()); ASL_TEST_EXPECT(s.code() == asl::status_code::internal); ASL_TEST_EXPECT(s.message() == ""_sv); - asl::status_or s2 = asl::internal_error("oh no"); + const asl::status_or s2 = asl::internal_error("oh no"); ASL_TEST_EXPECT(!s2.ok()); ASL_TEST_EXPECT(s2.code() == asl::status_code::internal); ASL_TEST_EXPECT(s2.message() == "oh no"_sv); - asl::status_or s3 = asl::internal_error("{} {}", 1, 2); + const asl::status_or s3 = asl::internal_error("{} {}", 1, 2); ASL_TEST_EXPECT(!s3.ok()); ASL_TEST_EXPECT(s3.code() == asl::status_code::internal); ASL_TEST_EXPECT(s3.message() == "1 2"_sv); @@ -53,7 +53,7 @@ ASL_TEST(destructor) ASL_TEST_EXPECT(!d); asl::status_or s2 = std::move(s); - ASL_TEST_EXPECT(s.ok()); + ASL_TEST_EXPECT(s2.ok()); ASL_TEST_EXPECT(!d); s = std::move(s2); @@ -79,8 +79,8 @@ ASL_TEST(copy) ASL_TEST(value_or) { - asl::status_or s = 7; - asl::status_or s2 = asl::internal_error(); + const asl::status_or s = 7; + const asl::status_or s2 = asl::internal_error(); ASL_TEST_EXPECT(s.value_or(45) == 7); ASL_TEST_EXPECT(s2.value_or(45) == 45); diff --git a/asl/types/status_tests.cpp b/asl/types/status_tests.cpp index 362556d..60715f5 100644 --- a/asl/types/status_tests.cpp +++ b/asl/types/status_tests.cpp @@ -9,14 +9,14 @@ ASL_TEST(simple_ok) { - asl::status s = asl::ok(); + const asl::status s = asl::ok(); ASL_TEST_ASSERT(s.ok()); ASL_TEST_ASSERT(s.code() == asl::status_code::ok); } ASL_TEST(simple_code) { - asl::status s = asl::runtime_error(); + const asl::status s = asl::runtime_error(); ASL_TEST_ASSERT(!s.ok()); ASL_TEST_ASSERT(s.code() == asl::status_code::runtime); ASL_TEST_ASSERT(s.message() == ""_sv); @@ -24,7 +24,7 @@ ASL_TEST(simple_code) ASL_TEST(with_message) { - asl::status s = asl::internal_error("We done goofed"); + const asl::status s = asl::internal_error("We done goofed"); ASL_TEST_ASSERT(!s.ok()); ASL_TEST_ASSERT(s.code() == asl::status_code::internal); ASL_TEST_ASSERT(s.message() == "We done goofed"_sv); @@ -32,8 +32,8 @@ ASL_TEST(with_message) ASL_TEST(copy_inline) { - asl::status s = asl::ok(); - asl::status s2 = asl::internal_error(); + const asl::status s = asl::ok(); + const asl::status s2 = asl::internal_error(); asl::status s3 = s; ASL_TEST_ASSERT(s3.code() == asl::status_code::ok); @@ -47,7 +47,7 @@ ASL_TEST(copy_message) asl::status s2 = asl::ok(); { - asl::status s = asl::internal_error("Oh no!"); + const asl::status s = asl::internal_error("Oh no!"); ASL_TEST_ASSERT(!s.ok()); ASL_TEST_ASSERT(s.code() == asl::status_code::internal); ASL_TEST_ASSERT(s.message() == "Oh no!"_sv); -- cgit