Bug#37273525 libc++ is deprecating/removing char_traits<unsigned char> [noclose]

The LLVM libc++ library is deprecating/removing char_traits<unsigned char>
  See https://reviews.llvm.org/D157058

The deprecation comes with clang-18, removal with clang-19

This means that our code using e.g.
  std::basic_string<uchar>
  std::basic_ostringstream<unsigned char>
will no longer compile for
  clang/gcc -stdlib=libc++

We usually build with -stdlib=libstdc++
which is the standard library that comes with gcc.
The exception is MacOS, where we always use libc++

Implement our own standards-compliant my_char_traits<unsigned char>
and use that as a drop-in replacement for std::char_traits<unsigned char>

Change-Id: I3cd16503543e74dff852d8708766181807910f00
(cherry picked from commit 0ca5bb128763857c1e5dd6f34796aaa922677611)

Author: Tor Didriksen

include/my_char_traits.h

@@ -0,0 +1,65 @@
+/* Copyright (c) 2024, Oracle and/or its affiliates.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License, version 2.0,
+   as published by the Free Software Foundation.
+
+   This program is designed to work with certain software (including
+   but not limited to OpenSSL) that is licensed under separate terms,
+   as designated in a particular file or component or in included license
+   documentation.  The authors of MySQL hereby grant you an additional
+   permission to link the program and your derivative works with the
+   separately licensed software that they have either included with
+   the program or referenced in the documentation.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License, version 2.0, for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#ifndef MY_CHAR_TRAITS_INCLUDED
+#define MY_CHAR_TRAITS_INCLUDED
+
+#include <cstring>
+
+template <class CharT>
+struct my_char_traits;
+
+/*
+  This is a standards-compliant, drop-in replacement for
+    std::char_traits<unsigned char>
+  We need this because clang libc++ is removing support for it in clang 19.
+  It is not a complete implementation. Rather we implement just enough to
+  compile any usage of char_traits<uchar> we have in our codebase.
+ */
+template <>
+struct my_char_traits<unsigned char> {
+  using char_type = unsigned char;
+  using int_type = unsigned int;
+
+  static void assign(char_type &c1, const char_type &c2) { c1 = c2; }
+
+  static char_type *assign(char_type *s, std::size_t n, char_type a) {
+    return static_cast<char_type *>(memset(s, a, n));
+  }
+
+  static int compare(const char_type *s1, const char_type *s2, std::size_t n) {
+    return memcmp(s1, s2, n);
+  }
+
+  static char_type *move(char_type *s1, const char_type *s2, std::size_t n) {
+    if (n == 0) return s1;
+    return static_cast<char_type *>(memmove(s1, s2, n));
+  }
+
+  static char_type *copy(char_type *s1, const char_type *s2, std::size_t n) {
+    if (n == 0) return s1;
+    return static_cast<char_type *>(memcpy(s1, s2, n));
+  }
+};
+
+#endif  // MY_CHAR_TRAITS_INCLUDED

sql/mdl_context_backup.h

@@ -28,6 +28,7 @@
 #include <map>
 #include <memory>
 
+#include "my_char_traits.h"
 #include "sql/malloc_allocator.h"
 #include "sql/mdl.h"
 
@@ -47,7 +48,8 @@ class MDL_context_backup_manager {
   /**
     Key for uniquely identifying MDL_context in the MDL_context_backup map.
   */
-  typedef std::basic_string<uchar> MDL_context_backup_key;
+  using MDL_context_backup_key =
+      std::basic_string<uchar, my_char_traits<uchar>>;
 
   class MDL_context_backup;
 

sql/stream_cipher.h

@@ -28,14 +28,17 @@
 #include <memory>
 #include <string>
 
+#include "my_char_traits.h"
+
 /**
   @file stream_cipher.h
 
   @brief This file includes core components for encrypting/decrypting
          binary log files.
 */
 
-typedef std::basic_string<unsigned char> Key_string;
+using Key_string =
+    std::basic_string<unsigned char, my_char_traits<unsigned char>>;
 
 /**
   @class Stream_cipher

unittest/gunit/binlogevents/transaction_compression-t.cc

@@ -23,6 +23,7 @@
 */
 
 #include <array>
+#include <string>
 
 #include <gtest/gtest.h>
 #include "mysql/binlog/event/binary_log.h"
@@ -49,13 +50,12 @@ class TransactionPayloadCompressionTest : public ::testing::Test {
   using Managed_buffer_t = Decompressor_t::Managed_buffer_t;
   using Size_t = Decompressor_t::Size_t;
   using Char_t = Decompressor_t::Char_t;
-  using String_t = std::basic_string<Char_t>;
   using Decompress_status_t =
       mysql::binlog::event::compression::Decompress_status;
   using Compress_status_t = mysql::binlog::event::compression::Compress_status;
 
-  static String_t constant_data(Size_t size) {
-    return String_t(size, (Char_t)'a');
+  static std::string constant_data(Size_t size) {
+    return std::string(size, (Char_t)'a');
   }
 
  protected:
@@ -66,7 +66,7 @@ class TransactionPayloadCompressionTest : public ::testing::Test {
   void TearDown() override {}
 
   static void compression_idempotency_test(Compressor_t &c, Decompressor_t &d,
-                                           String_t data) {
+                                           const std::string &data) {
     auto debug_string = concat(
         mysql::binlog::event::compression::type_to_string(c.get_type_code()),
         " ", data.size());
@@ -101,8 +101,8 @@ class TransactionPayloadCompressionTest : public ::testing::Test {
 
     // Check decompressed data
     ASSERT_EQ(managed_buffer.read_part().size(), data.size()) << debug_string;
-    ASSERT_EQ(data, String_t(managed_buffer.read_part().begin(),
-                             managed_buffer.read_part().end()))
+    ASSERT_EQ(data, std::string(managed_buffer.read_part().begin(),
+                                managed_buffer.read_part().end()))
         << debug_string;
 
     // Check that we reached EOF
@@ -115,7 +115,7 @@ TEST_F(TransactionPayloadCompressionTest, CompressDecompressZstdTest) {
   for (auto size : buffer_sizes) {
     mysql::binlog::event::compression::Zstd_dec d;
     mysql::binlog::event::compression::Zstd_comp c;
-    String_t data{TransactionPayloadCompressionTest::constant_data(size)};
+    std::string data{TransactionPayloadCompressionTest::constant_data(size)};
     TransactionPayloadCompressionTest::compression_idempotency_test(c, d, data);
     c.set_compression_level(22);
     TransactionPayloadCompressionTest::compression_idempotency_test(c, d, data);
@@ -126,7 +126,7 @@ TEST_F(TransactionPayloadCompressionTest, CompressDecompressNoneTest) {
   for (auto size : buffer_sizes) {
     mysql::binlog::event::compression::None_dec d;
     mysql::binlog::event::compression::None_comp c;
-    String_t data{TransactionPayloadCompressionTest::constant_data(size)};
+    std::string data{TransactionPayloadCompressionTest::constant_data(size)};
     TransactionPayloadCompressionTest::compression_idempotency_test(c, d, data);
   }
 }