Bug#35362952 Prepare the codebase for C++20

At some point in the future, we will most likely want to switch from
C++17 to C++20.  Prepare the codebase for this, by rewriting it to be
valid for both C++17 and C++20.

Details:

================

All member functions Foo::operator==(const Foo&) must be const.

Otherwise Clang will complain:

ISO C++20 considers use of overloaded operator '==' ....
to be ambiguous despite there being a unique best viable function
[-Werror,-Wambiguous-reversed-operator]

================

ICU cannot be built with -std=c++20
It has a homegrown type
   typedef int8_t UBool;

and there are plenty of warnings like: return type of virtual
UBool icu_69::TimeArrayTimeZoneRule::operator==(const icu_69::TimeZoneRule&)
const is not bool

and there is no warning to disable, operator==() *must* return bool.

The solution is to downgrade to -std=c++17 when building ICU.

================

Several warnings of the type:

increment of object of volatile-qualified type 'volatile int32'
(aka 'volatile int') is deprecated [-Werror,-Wdeprecated-volatile]
or alternatively volatile-qualified type is deprecated [-Werror=volatile]

Most of these volatile variables should be converted to std::atomic<>
but some cannot, if they are members of classes which need copy
construction, or copy assignment.

================

Both clang and gcc say:
pfs_example_continent.cc:273:50: error: no match for
operator= (operand types are PFS_engine_table_proxy and
  <brace-enclosed initializer list>)

The solution is to remove the default CTOR of PFS_engine_table_proxy.

================

scheduler_imp.cc:420:49: error: memory_order_acquire is not a member
of std::memory_order

================

Template arguments should not be repeated in CTORs/DTORs
error: expected unqualified-id before ) token
  287 |     Lockless_hash<T>();

================

package <utility> for gcc12, which an in_range() function.

The macro is unused, so just remove it.

================
clang complains:

router/src/harness/include/mysql/harness/net_ts/executor.h:173:46:
error: member access into incomplete type
'net::execution_context::service

The solution is to move the implementation of a couple of member
functions later in the same source file.

================

error: no matching function for call to object of type
'(lambda at router/src/http/tests/test_passwd.cc:100:19)
router/src/http/tests/test_passwd.cc:100:19: note:
candidate function not viable: expects an lvalue for 1st argument

================

in sql/auth/sql_authorization.cc
move some 'bool operator==()' functions up so they are visible when we do

find(granted_roles.begin(), granted_roles.end(), role_id)

================

sql/field.cc:5570:22: warning: comparison of floating-point type double
with enumeration type Field_year::Limits is deprecated
[-Wdeprecated-enum-float-conversion]

Add explicit static_cast.
================

log_event.cc
make slave_skip_counter std::atomic

implicit capture of 'this' via [=] is deprecated in C++20 [-Wdeprecated]
Make an explicit list of captured variables instead.

================

sql_bitmap.h
do not repeat template parameters in CTOR/DTOR

================

sql_lex.h
sql/sql_lex.h:2860:45: error:
arithmetic between different enumeration types
('Query_tables_list::enum_binlog_stmt_unsafe' and
  'Query_tables_list::enum_binlog_stmt_type')

is deprecated [-Werror,-Wdeprecated-enum-enum-conversion]

================

Misc places in storage/innobase

implicit capture of 'this' via [=] is deprecated in C++20 [-Wdeprecated]

================

gcc12 complains about
test_net_ts_timer.cc:144:36:
error: redefinition of 'template<class CharT, class Traits, class Rep,
class Period> std::basic_ostream<_CharT, _Traits>&
std::chrono::operator<<(std::basic_ostream<_CharT, _Traits>&, const
duration<_Rep2, _Period2>&)'

The fix is to  change the feature test.

================
clang on loki09:

plugin/data_masking/datamask.cc:27:13:
error: instantiation of variable
'datamasking::Generator<std::basic_string<char>>::REGISTRY'
required here, but no definition is available [-Werror,-Wundefined-var-template]
    switch (REGISTRY.has(token.get_blacklist(), ctx.m_in)) {

the fix is to move implementation of
Generator<T>::generate(const Dictionary_token<T> &token, Context<T> &ctx)
to plugin/data_masking/udf/functions.cc

================
clang 13/14 on Linux:
sql/log_event.cc:7964:15: error: explicit capture of 'this' with a capture default of '=' is a C++20 extension [-Werror,-Wc++20-extensions]
          [=, this](TABLE const *table, size_t column_index) -> bool

================
strings_strnxfrm-t.cc
error: invalid conversion from const char8_t* to const char*

Change-Id: I51c24560bb72c071996fc2f4d85c5506fac523b5

Author: Tor Didriksen

CMakeLists.txt

@@ -789,6 +789,33 @@ IF(WITH_DEFAULT_COMPILER_OPTIONS)
   INCLUDE(${CMAKE_SOURCE_DIR}/cmake/build_configurations/compiler_options.cmake)
 ENDIF()
 
+OPTION(WITH_EXPERIMENTAL_CPP20
+  "Build with -std=c++20, note: this is experimental" OFF)
+
+IF(WITH_EXPERIMENTAL_CPP20)
+  IF(MY_COMPILER_IS_GNU)
+    IF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
+      MESSAGE(FATAL_ERROR "GCC 10 or newer is required for -std=c++20")
+    ENDIF()
+  ELSEIF(MY_COMPILER_IS_CLANG)
+    IF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11.0)
+      MESSAGE(FATAL_ERROR "Clang 11 or newer is required for -std=c++20")
+    ENDIF()
+  ENDIF()
+  IF(UNIX)
+    STRING(REPLACE "-std=c++17" "-std=c++20"
+      CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  ELSE()
+    FOREACH(flag
+        CMAKE_CXX_FLAGS_MINSIZEREL
+        CMAKE_CXX_FLAGS_RELEASE  CMAKE_CXX_FLAGS_RELWITHDEBINFO
+        CMAKE_CXX_FLAGS_DEBUG    CMAKE_CXX_FLAGS_DEBUG_INIT
+        )
+      STRING(REPLACE "/std:c++17" "/std:c++20" ${flag} "${${flag}}")
+    ENDFOREACH()
+  ENDIF()
+ENDIF()
+
 # Assume, for now at least, that we want build-id for all kinds of Linux builds.
 IF(LINUX)
   OPTION(WITH_BUILD_ID "Add --build-id=sha1 to all executables." ON)

components/keyrings/common/data/data.cc

@@ -88,7 +88,7 @@ void Data::set_type(Type type) {
 }
 
 /** Comparison */
-bool Data::operator==(const Data &other) {
+bool Data::operator==(const Data &other) const {
   return data_ == other.data_ && type_ == other.type_ && valid_ == other.valid_;
 }
 

components/keyrings/common/data/data.h

@@ -62,7 +62,7 @@ class Data {
 
   void set_type(Type type);
 
-  bool operator==(const Data &other);
+  bool operator==(const Data &other) const;
 
  protected:
   void set_validity();

extra/icu/CMakeLists.txt

@@ -129,6 +129,31 @@ IF(HAS_WARN_FLAG)
   LIST(APPEND ICU_LINUX_COMPILE_OPTIONS "${HAS_WARN_FLAG}")
 ENDIF()
 
+# typedef int8_t UBool; results in
+# error: return type of virtual UBool xxx::operator==(const xxx&) is not bool
+IF(CMAKE_CXX_FLAGS MATCHES "-std=c..20")
+  STRING(REPLACE "-std=c++20" "-std=c++17" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+ENDIF()
+
+IF(WIN32)
+  # In case we have switched on c++20 elsewhere
+  FOREACH(flag
+      CMAKE_CXX_FLAGS_MINSIZEREL
+      CMAKE_CXX_FLAGS_RELEASE  CMAKE_CXX_FLAGS_RELWITHDEBINFO
+      CMAKE_CXX_FLAGS_DEBUG    CMAKE_CXX_FLAGS_DEBUG_INIT
+      )
+    IF("${${flag}}" MATCHES "/std:c..20")
+      STRING(REPLACE "/std:c++20" "/std:c++17" ${flag} "${${flag}}")
+    ENDIF()
+  ENDFOREACH()
+ENDIF()
+
+# warning: arithmetic between different enumeration types is deprecated
+MY_CHECK_CXX_COMPILER_WARNING("-Wdeprecated-enum-enum-conversion" HAS_WARN_FLAG)
+IF(HAS_WARN_FLAG)
+  LIST(APPEND ICU_LINUX_COMPILE_OPTIONS "${HAS_WARN_FLAG}")
+ENDIF()
+
 IF(WIN32)
   ADD_DEFINITIONS(
     -DU_STATIC_IMPLEMENTATION=1

extra/zlib/zlib-1.2.13/CMakeLists.txt

@@ -156,10 +156,11 @@ IF(HAS_MISSING_PROFILE)
   ADD_COMPILE_FLAGS(${ZLIB_SRCS} COMPILE_FLAGS ${HAS_MISSING_PROFILE})
 ENDIF()
 
-MY_CHECK_CXX_COMPILER_WARNING("-Wdeprecated-non-prototype"
+# clang has this, but clang++ does not.
+MY_CHECK_C_COMPILER_FLAG("-Wdeprecated-non-prototype"
   HAS_DEPRECATED_NON_PROTOTYPE)
 IF(HAS_DEPRECATED_NON_PROTOTYPE)
-  ADD_COMPILE_FLAGS(${ZLIB_SRCS} COMPILE_FLAGS ${HAS_DEPRECATED_NON_PROTOTYPE})
+  ADD_COMPILE_FLAGS(${ZLIB_SRCS} COMPILE_FLAGS "-Wno-deprecated-non-prototype")
 ENDIF()
 
 IF(NOT WIN32)

include/mysql/components/services/log_builtins_filter.h

@@ -23,6 +23,8 @@
 #ifndef LOG_BUILTINS_FILTER_H
 #define LOG_BUILTINS_FILTER_H
 
+#include <atomic>
+
 #include <mysql/components/component_implementation.h>
 #include <mysql/components/my_service.h>
 #include <mysql/components/service_implementation.h>
@@ -138,10 +140,27 @@ typedef struct _log_filter_rule {
   ulong flags;
 
   /** how often did this rule match? */
-  volatile int32 match_count;
+  std::atomic<int32> match_count;
 
   /** lock an individual rule (to update state keeping) */
   mysql_rwlock_t rule_lock;
+
+  _log_filter_rule &operator=(const _log_filter_rule &other) {
+    if (this == &other) return *this;
+    id = other.id;
+    jump = other.jump;
+    match = other.match;
+    cond = other.cond;
+    verb = other.verb;
+    aux = other.aux;
+    throttle_window_end = other.throttle_window_end;
+    throttle_window_size = other.throttle_window_size;
+    throttle_matches = other.throttle_matches;
+    flags = other.flags;
+    match_count = other.match_count.load();
+    rule_lock = other.rule_lock;
+    return *this;
+  }
 } log_filter_rule;
 
 #define LOG_FILTER_RULE_MAX 512

include/mysql/components/services/pfs_plugin_table_service.h

@@ -410,22 +410,21 @@ typedef void (*close_table_t)(PSI_table_handle *handle);
  plugin/component.
 */
 struct PFS_engine_table_proxy {
-  rnd_next_t rnd_next;
-  rnd_init_t rnd_init;
-  rnd_pos_t rnd_pos;
-  index_init_t index_init;
-  index_read_t index_read;
-  index_next_t index_next;
-  read_column_value_t read_column_value;
-  reset_position_t reset_position;
-  write_column_value_t write_column_value;
-  write_row_values_t write_row_values;
-  update_column_value_t update_column_value;
-  update_row_values_t update_row_values;
-  delete_row_values_t delete_row_values;
-  open_table_t open_table;
-  close_table_t close_table;
-  PFS_engine_table_proxy() = default;
+  rnd_next_t rnd_next{nullptr};
+  rnd_init_t rnd_init{nullptr};
+  rnd_pos_t rnd_pos{nullptr};
+  index_init_t index_init{nullptr};
+  index_read_t index_read{nullptr};
+  index_next_t index_next{nullptr};
+  read_column_value_t read_column_value{nullptr};
+  reset_position_t reset_position{nullptr};
+  write_column_value_t write_column_value{nullptr};
+  write_row_values_t write_row_values{nullptr};
+  update_column_value_t update_column_value{nullptr};
+  update_row_values_t update_row_values{nullptr};
+  delete_row_values_t delete_row_values{nullptr};
+  open_table_t open_table{nullptr};
+  close_table_t close_table{nullptr};
 };
 typedef struct PFS_engine_table_proxy PFS_engine_table_proxy;
 

include/mysql/service_rules_table.h

@@ -113,7 +113,7 @@ class Cursor {
     Equality operator. The only cursors that are equal are past-the-end
     cursors.
   */
-  bool operator==(const Cursor &other) {
+  bool operator==(const Cursor &other) const {
     return (m_is_finished == other.m_is_finished);
   }
 

plugin/audit_null/audit_null.cc

@@ -161,6 +161,12 @@ static SHOW_VAR simple_status[] = {
 
     {nullptr, nullptr, SHOW_UNDEF, SHOW_SCOPE_GLOBAL}};
 
+static void increment_counter(volatile int *counter) {
+  int value = *counter;
+  int new_value = value + 1;
+  *counter = new_value;
+}
+
 /*
   Define plugin variables.
 */
@@ -455,24 +461,24 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
   bool consume_event = true;
 
   /* prone to races, oh well */
-  number_of_calls++;
+  increment_counter(&number_of_calls);
 
   if (event_class == MYSQL_AUDIT_GENERAL_CLASS) {
     const struct mysql_event_general *event_general =
         (const struct mysql_event_general *)event;
 
     switch (event_general->event_subclass) {
       case MYSQL_AUDIT_GENERAL_LOG:
-        number_of_calls_general_log++;
+        increment_counter(&number_of_calls_general_log);
         break;
       case MYSQL_AUDIT_GENERAL_ERROR:
-        number_of_calls_general_error++;
+        increment_counter(&number_of_calls_general_error);
         break;
       case MYSQL_AUDIT_GENERAL_RESULT:
-        number_of_calls_general_result++;
+        increment_counter(&number_of_calls_general_result);
         break;
       case MYSQL_AUDIT_GENERAL_STATUS:
-        number_of_calls_general_status++;
+        increment_counter(&number_of_calls_general_status);
         break;
       default:
         break;
@@ -483,16 +489,16 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (event_connection->event_subclass) {
       case MYSQL_AUDIT_CONNECTION_CONNECT:
-        number_of_calls_connection_connect++;
+        increment_counter(&number_of_calls_connection_connect);
         break;
       case MYSQL_AUDIT_CONNECTION_DISCONNECT:
-        number_of_calls_connection_disconnect++;
+        increment_counter(&number_of_calls_connection_disconnect);
         break;
       case MYSQL_AUDIT_CONNECTION_CHANGE_USER:
-        number_of_calls_connection_change_user++;
+        increment_counter(&number_of_calls_connection_change_user);
         break;
       case MYSQL_AUDIT_CONNECTION_PRE_AUTHENTICATE:
-        number_of_calls_connection_pre_authenticate++;
+        increment_counter(&number_of_calls_connection_pre_authenticate);
         break;
       default:
         break;
@@ -503,10 +509,10 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (event_parse->event_subclass) {
       case MYSQL_AUDIT_PARSE_PREPARSE:
-        number_of_calls_parse_preparse++;
+        increment_counter(&number_of_calls_parse_preparse);
         break;
       case MYSQL_AUDIT_PARSE_POSTPARSE:
-        number_of_calls_parse_postparse++;
+        increment_counter(&number_of_calls_parse_postparse);
         break;
       default:
         break;
@@ -558,11 +564,11 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
   else if (event_class == MYSQL_AUDIT_SERVER_STARTUP_CLASS) {
     /* const struct mysql_event_server_startup *event_startup=
        (const struct mysql_event_server_startup *) event; */
-    number_of_calls_server_startup++;
+    increment_counter(&number_of_calls_server_startup);
   } else if (event_class == MYSQL_AUDIT_SERVER_SHUTDOWN_CLASS) {
     /* const struct mysql_event_server_shutdown *event_startup=
        (const struct mysql_event_server_shutdown *) event; */
-    number_of_calls_server_shutdown++;
+    increment_counter(&number_of_calls_server_shutdown);
   } else if (event_class == MYSQL_AUDIT_COMMAND_CLASS) {
     const struct mysql_event_command *local_event_command =
         (const struct mysql_event_command *)event;
@@ -572,10 +578,10 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (local_event_command->event_subclass) {
       case MYSQL_AUDIT_COMMAND_START:
-        number_of_calls_command_start++;
+        increment_counter(&number_of_calls_command_start);
         break;
       case MYSQL_AUDIT_COMMAND_END:
-        number_of_calls_command_end++;
+        increment_counter(&number_of_calls_command_end);
         break;
       default:
         break;
@@ -589,16 +595,16 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (event_query->event_subclass) {
       case MYSQL_AUDIT_QUERY_START:
-        number_of_calls_query_start++;
+        increment_counter(&number_of_calls_query_start);
         break;
       case MYSQL_AUDIT_QUERY_NESTED_START:
-        number_of_calls_query_nested_start++;
+        increment_counter(&number_of_calls_query_nested_start);
         break;
       case MYSQL_AUDIT_QUERY_STATUS_END:
-        number_of_calls_query_status_end++;
+        increment_counter(&number_of_calls_query_status_end);
         break;
       case MYSQL_AUDIT_QUERY_NESTED_STATUS_END:
-        number_of_calls_query_nested_status_end++;
+        increment_counter(&number_of_calls_query_nested_status_end);
         break;
       default:
         break;
@@ -613,16 +619,16 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (event_table->event_subclass) {
       case MYSQL_AUDIT_TABLE_ACCESS_INSERT:
-        number_of_calls_table_access_insert++;
+        increment_counter(&number_of_calls_table_access_insert);
         break;
       case MYSQL_AUDIT_TABLE_ACCESS_DELETE:
-        number_of_calls_table_access_delete++;
+        increment_counter(&number_of_calls_table_access_delete);
         break;
       case MYSQL_AUDIT_TABLE_ACCESS_UPDATE:
-        number_of_calls_table_access_update++;
+        increment_counter(&number_of_calls_table_access_update);
         break;
       case MYSQL_AUDIT_TABLE_ACCESS_READ:
-        number_of_calls_table_access_read++;
+        increment_counter(&number_of_calls_table_access_read);
         break;
       default:
         break;
@@ -649,10 +655,10 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (event_gvar->event_subclass) {
       case MYSQL_AUDIT_GLOBAL_VARIABLE_GET:
-        number_of_calls_global_variable_get++;
+        increment_counter(&number_of_calls_global_variable_get);
         break;
       case MYSQL_AUDIT_GLOBAL_VARIABLE_SET:
-        number_of_calls_global_variable_set++;
+        increment_counter(&number_of_calls_global_variable_set);
         break;
       default:
         break;
@@ -699,10 +705,10 @@ static int audit_null_notify(MYSQL_THD thd, mysql_event_class_t event_class,
 
     switch (evt->event_subclass) {
       case MYSQL_AUDIT_MESSAGE_INTERNAL:
-        number_of_calls_message_internal++;
+        increment_counter(&number_of_calls_message_internal);
         break;
       case MYSQL_AUDIT_MESSAGE_USER:
-        number_of_calls_message_user++;
+        increment_counter(&number_of_calls_message_user);
         break;
       default:
         break;

plugin/group_replication/libmysqlgcs/src/bindings/xcom/xcom/xdr_utils.h

@@ -55,9 +55,6 @@ extern "C" u_long xdr_sizeof(xdrproc_t, void *);
     x->name##_array_len = 0;   \
   }
 
-#define in_range(x, name, n) \
-  (((int)n) >= 0 && ((int)n) < ((int)(x).name##_array_len))
-
 /**
     Resize an array
  */

plugin/keyring/digest.cc

@@ -56,7 +56,7 @@ void Digest::assign(const char *value) {
   is_empty = false;
 }
 
-bool Digest::operator==(const Digest &digest) {
+bool Digest::operator==(const Digest &digest) const {
   return this->is_empty == digest.is_empty && this->length == digest.length &&
          memcmp(this->value, digest.value, this->length) == 0;
 }

plugin/keyring/digest.h

@@ -40,7 +40,7 @@ class Digest {
   ~Digest();
 
   void assign(const char *value);
-  bool operator==(const Digest &digest);
+  bool operator==(const Digest &digest) const;
   Digest &operator=(const Digest &digest);
   void compute(uchar *memory, size_t memory_size);