Addressing some static analysis warnings. (#179)

Avoid native integer types in favor of explicitly sized types. Avoid
bitwise operations on signed types. Eliminate a TODO: replaced with a
comment stating that the code should be removed when possible.

Author: paulhuggett

examples/bytes_to_utf8.cpp

@@ -1,4 +1,10 @@
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
 #include <iostream>
+#include <iterator>
+#include <ranges>
 
 #include "icubaby/icubaby.hpp"
 

include/icubaby/icubaby.hpp

@@ -815,7 +815,7 @@ template <> class transcoder<char32_t, char8> {
   /// \param dest  An output iterator to which the output sequence is written.
   /// \returns  Iterator one past the last element assigned.
   template <ICUBABY_CONCEPT_OUTPUT_ITERATOR (output_type) OutputIterator>
-  static constexpr OutputIterator write_continuation (unsigned const number, input_type const code_unit,
+  static constexpr OutputIterator write_continuation (std::uint_least8_t const number, input_type const code_unit,
                                                       OutputIterator dest) {
     if (number == 0U) {
       return dest;
@@ -827,6 +827,8 @@ template <> class transcoder<char32_t, char8> {
 
   /// Writes a two CU value to the output.
   ///
+  /// Code points in the range [U+80, U+800) are represented as two UTF-8 code units.
+  ///
   /// \tparam OutputIterator  An output iterator type to which values of type output_type can be written.
   /// \param code_unit  The code unit to be written.
   /// \param dest  An output iterator to which the output sequence is written.
@@ -835,10 +837,12 @@ template <> class transcoder<char32_t, char8> {
   static OutputIterator write2 (input_type code_unit, OutputIterator dest) {
     assert (code_unit >= 0x80U && code_unit <= 0x7FFU && "Code point is out-of-range for 2 byte UTF-8");
     *(dest++) = static_cast<output_type> ((code_unit >> details::utf8_shift) | byte_1_of_2);
-    return transcoder::write_continuation (1U, code_unit, dest);
+    return transcoder::write_continuation (std::uint_least8_t{1}, code_unit, dest);
   }
   /// Writes a three CU value to the output.
   ///
+  /// Code points in the range [U+800, U+10000) are represented as three UTF-8 code units.
+  ///
   /// \tparam OutputIterator  An output iterator type to which values of type output_type can be written.
   /// \param code_unit  The code unit to be written.
   /// \param dest  An output iterator to which the output sequence is written.
@@ -847,10 +851,12 @@ template <> class transcoder<char32_t, char8> {
   static OutputIterator write3 (input_type code_unit, OutputIterator dest) {
     assert (code_unit >= 0x800U && code_unit <= 0xFFFFU && "Code point is out-of-range for 3 byte UTF-8");
     *(dest++) = static_cast<output_type> ((code_unit >> (details::utf8_shift * 2U)) | byte_1_of_3);
-    return transcoder::write_continuation (2U, code_unit, dest);
+    return transcoder::write_continuation (std::uint_least8_t{2}, code_unit, dest);
   }
   /// Writes a four CU value to the output.
   ///
+  /// Code points in the range [U+10000, U+10FFFF] are represented as four UTF-8 code units.
+  ///
   /// \tparam OutputIterator  An output iterator type to which values of type output_type can be written.
   /// \param code_unit  The code unit to be written.
   /// \param dest  An output iterator to which the output sequence is written.
@@ -859,7 +865,7 @@ template <> class transcoder<char32_t, char8> {
   static OutputIterator write4 (input_type code_unit, OutputIterator dest) {
     assert (code_unit >= 0x10000U && code_unit <= 0x10FFFFU && "Code point is out-of-range for 4 byte UTF-8");
     *(dest++) = static_cast<output_type> ((code_unit >> (details::utf8_shift * 3U)) | byte_1_of_4);
-    return transcoder::write_continuation (3U, code_unit, dest);
+    return transcoder::write_continuation (std::uint_least8_t{3}, code_unit, dest);
   }
   /// Writes U+FFFD REPLACEMENT CHAR to the output and records the input as not well formed.
   ///
@@ -1212,7 +1218,7 @@ template <> class transcoder<char16_t, char32_t> {
 };
 
 /// \brief An enumeration representing the encoding detected by transcoder<std::byte, X>.
-enum class encoding {
+enum class encoding : std::uint_least8_t {
   unknown,  ///< No encoding has yet been determined.
   utf8,     ///< The detected encoding is UTF-8.
   utf16be,  ///< The detected encoding is big-endian UTF-16.
@@ -1616,9 +1622,9 @@ template <ICUBABY_CONCEPT_UNICODE_CHAR_TYPE ToEncoding> class transcoder<std::by
   }
 
   /// \brief Returns a byte from the byte order marker table which corresponds to a specific state as denoted by
-  ///   \p state_byte and byte count \p byte_number.the
+  ///   \p state_byte and byte count \p byte_number.
   ///
-  /// \param state  A valid state machine state.
+  /// \param state_byte  A valid state machine state.
   /// \param byte_number  The index of the byte within the byte order marker.
   /// \returns  A byte from the byte order marker table.
   [[nodiscard]] static constexpr std::byte bom_value (std::byte const state_byte,
@@ -1637,9 +1643,8 @@ template <ICUBABY_CONCEPT_UNICODE_CHAR_TYPE ToEncoding> class transcoder<std::by
     return enc[byte_number];
   }
   /// \brief Returns a byte from the byte order marker table which corresponds to a specific state as denoted by
-  ///   the current state and byte count \p byte_number.the
+  ///   the current state and byte count
   ///
-  /// \param byte_number  The index of the byte within the byte order marker.
   /// \returns  A byte from the byte order marker table.
   [[nodiscard]] constexpr std::byte bom_value () const noexcept {
     return transcoder::bom_value (static_cast<std::byte> (state_), transcoder::get_byte_no (state_));
@@ -1793,16 +1798,17 @@ template <ICUBABY_CONCEPT_UNICODE_CHAR_TYPE ToEncoding> class transcoder<std::by
   /// \param value An input byte
   /// \returns A native-endian 16 bit value.
   [[nodiscard]] constexpr char16_t char16_from_big_endian_buffer (input_type const value) const noexcept {
-    return static_cast<char16_t> ((static_cast<std::uint_least16_t> (buffer_[0]) << 8U) |
-                                  static_cast<std::uint_least16_t> (value));
+    return static_cast<char16_t> (
+        static_cast<std::uint_least16_t> (static_cast<std::uint_least16_t> (buffer_[0]) << 8U) |
+        static_cast<std::uint_least16_t> (value));
   }
   /// \brief Produces a native-endian 16-bit value from little endian encoded input by combining the first entry in the
   ///        buffer_ array with \p value.
   ///
   /// \param value An input byte
   /// \returns A native-endian 16 bit value.
   [[nodiscard]] constexpr char16_t char16_from_little_endian_buffer (input_type const value) const noexcept {
-    return static_cast<char16_t> ((static_cast<std::uint_least16_t> (value) << 8U) |
+    return static_cast<char16_t> (static_cast<std::uint_least16_t> (static_cast<std::uint_least16_t> (value) << 8U) |
                                   static_cast<std::uint_least16_t> (buffer_[0]));
   }
   /// \brief Produces a native-endian 32-bit value from big endian encoded input by combining the entries in the
@@ -1811,10 +1817,11 @@ template <ICUBABY_CONCEPT_UNICODE_CHAR_TYPE ToEncoding> class transcoder<std::by
   /// \param value An input byte
   /// \returns A native-endian 32 bit value.
   [[nodiscard]] constexpr char32_t char32_from_big_endian_buffer (input_type const value) const noexcept {
-    return static_cast<char32_t> ((static_cast<std::uint_least32_t> (buffer_[0]) << 24U) |
-                                  (static_cast<std::uint_least32_t> (buffer_[1]) << 16U) |
-                                  (static_cast<std::uint_least32_t> (buffer_[2]) << 8U) |
-                                  static_cast<std::uint_least32_t> (value));
+    return static_cast<char32_t> (
+        static_cast<std::uint_least32_t> (static_cast<std::uint_least32_t> (buffer_[0]) << 24U) |
+        static_cast<std::uint_least32_t> (static_cast<std::uint_least32_t> (buffer_[1]) << 16U) |
+        static_cast<std::uint_least32_t> (static_cast<std::uint_least32_t> (buffer_[2]) << 8U) |
+        static_cast<std::uint_least32_t> (value));
   }
   /// \brief Produces a native-endian 32-bit value from little endian encoded input by combining the entries in the
   ///        buffer_ array with \p value.

tests/demo8/demo8.cpp

@@ -73,7 +73,7 @@ class ios_flags_saver {
   ios_flags_saver (ios_flags_saver const&) = delete;
   ios_flags_saver (ios_flags_saver&&) noexcept = delete;
 
-  ~ios_flags_saver () { stream_->flags (flags_); }
+  ~ios_flags_saver () { (void)stream_->flags (flags_); }
 
   ios_flags_saver& operator= (ios_flags_saver const&) = delete;
   ios_flags_saver& operator= (ios_flags_saver&&) noexcept = delete;

tests/iconv/iconv.cpp

@@ -42,9 +42,10 @@ namespace {
 #if defined(__cpp_lib_endian) && __cpp_lib_endian >= 201907L
 using std::endian;
 #elif defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) && defined(__BYTE_ORDER__)
+// NOLINTNEXTLINE(performance-enum-size)
 enum class endian { little = __ORDER_LITTLE_ENDIAN__, big = __ORDER_BIG_ENDIAN__, native = __BYTE_ORDER__ };
 #elif defined(_WIN32) || defined(__i386__) || defined(__x86_64__)
-enum class endian { little = 0, big = 1, native = little };
+enum class endian : std::uint_least8_t { little = 0, big = 1, native = little };
 #else
 #error "Can't determine endianness of the target system"
 #endif
@@ -82,6 +83,7 @@ constexpr ResultType pointer_cast (ArgType *const ptr) noexcept {
 #else
   ResultType result = nullptr;
   static_assert (sizeof (ptr) == sizeof (result));
+  // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)
   (void)std::memcpy (&result, &ptr, sizeof (result));
   return result;
 #endif

tests/performance/performance.cpp

@@ -138,7 +138,8 @@ template <typename FromEncoding, typename ToEncoding> ICUBABY_NOINLINE void go (
   auto const elapsed = std::chrono::steady_clock::now () - start_time;
   std::cout << static_cast<double> (std::chrono::duration_cast<std::chrono::milliseconds> (elapsed).count ()) /
                    static_cast<double> (iterations)
-            << " ms" << std::endl;
+            << " ms\n"
+            << std::flush;
 }
 
 std::uint_least16_t iteration_count (std::string_view const str) {
@@ -167,7 +168,7 @@ int main (int const argc, char const *argv[]) {
     }
     // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
     auto const iterations = iteration_count (argc > 1 ? argv[1] : "16");
-    std::cout << "Time to transcode all code points (" << iterations << " iterations):" << std::endl;
+    std::cout << "Time to transcode all code points (" << iterations << " iterations):\n" << std::flush;
     go<char8, char8> (iterations);
     go<char8, char16_t> (iterations);
     go<char8, char32_t> (iterations);

tests/ranges/ranges.cpp

@@ -92,7 +92,7 @@ class ios_flags_saver {
   ios_flags_saver (ios_flags_saver const&) = delete;
   ios_flags_saver (ios_flags_saver&&) noexcept = delete;
 
-  ~ios_flags_saver () { stream_->flags (flags_); }
+  ~ios_flags_saver () { (void)stream_->flags (flags_); }
 
   ios_flags_saver& operator= (ios_flags_saver const&) = delete;
   ios_flags_saver& operator= (ios_flags_saver&&) noexcept = delete;

unittests/encoded_char.hpp

@@ -20,9 +20,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#ifndef ICUBABY_UNITTESTS_ENCODED_CHAR_HPP
-#define ICUBABY_UNITTESTS_ENCODED_CHAR_HPP
+#ifndef ICUBABY_ENCODED_CHAR_HPP
+#define ICUBABY_ENCODED_CHAR_HPP (1)
 
+#include <algorithm>
 #include <array>
 
 #include "icubaby/icubaby.hpp"
@@ -534,4 +535,4 @@ template <code_point C, typename To, typename OutputIterator> OutputIterator app
 #endif  // ICUBABY_HAVE_RANGES
 }
 
-#endif  // ICUBABY_UNITTESTS_ENCODED_CHAR_HPP
+#endif  // ICUBABY_ENCODED_CHAR_HPP

unittests/test_byte.cpp

@@ -31,6 +31,10 @@
 #include <ostream>
 #include <vector>
 
+#if ICUBABY_HAVE_RANGES
+#include <ranges>
+#endif  // ICUBABY_HAVE_RANGES
+
 // google mock/test/fuzz
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -422,7 +426,9 @@ TEST (ByteTranscoder, Utf16BEAndIterMove) {
 }
 #endif  // ICUBABY_HAVE_RANGES
 
-static void ByteTranscoderNeverCrashes (std::vector<std::byte> const& input) {
+namespace {
+
+void ByteTranscoderNeverCrashes (std::vector<std::byte> const& input) {
   icubaby::transcoder<std::byte, char32_t> transcoder;
   std::vector<char32_t> output;
   auto output_iterator = icubaby::iterator{&transcoder, std::back_inserter (output)};
@@ -433,6 +439,9 @@ static void ByteTranscoderNeverCrashes (std::vector<std::byte> const& input) {
 #endif  // ICUBABY_HAVE_RANGES
   (void)transcoder.end_cp (output_iterator);
 }
+
+}  // end anonymous namespace
+
 #if ICUBABY_FUZZTEST
 // NOLINTNEXTLINE
 FUZZ_TEST (ByteTranscoder, ByteTranscoderNeverCrashes);

unittests/typed_test.hpp

@@ -20,8 +20,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#ifndef ICUBABY_UNITTESTS_TYPED_TEST_HPP
-#define ICUBABY_UNITTESTS_TYPED_TEST_HPP
+#ifndef ICUBABY_TYPED_TEST_HPP
+#define ICUBABY_TYPED_TEST_HPP (1)
 
 #include <gtest/gtest.h>
 
@@ -30,9 +30,9 @@
 
 #include "icubaby/icubaby.hpp"
 
-// TODO(paul): Remove this code!
 // A specialization of the gtest GetTypeName<char8_t>() function. This is required for compiling with (at least)
-// Xcode 14.1/15.2 where we have a link error due to missing typeinfo for char8_t.
+// Xcode 14.1/15.2 where we have a link error due to missing typeinfo for char8_t. This code should be removed once it
+// is no longer needed for any of our targets.
 #if defined(__cpp_char8_t) && defined(__cpp_lib_char8_t)
 namespace testing::internal {
 
@@ -76,4 +76,4 @@ class OutputTypeNames {
 
 using OutputTypes = testing::Types<icubaby::char8, char16_t, char32_t>;
 
-#endif  // ICUBABY_UNITTESTS_TYPED_TEST_HPP
+#endif  // ICUBABY_TYPED_TEST_HPP