Bug#37471922: Auto-fix clang-tidy warnings [30/n] [noclose]

Generate fixes for a number of warnings that clang-tidy can fix automatically.
This commit fixes the warning 'modernize-use-override'.

Change example:
 - virtual ~Gcs_new_stage_1() override = default;
 + ~Gcs_new_stage_1() override = default;

Change-Id: Id0d95f200991ab019eec43a014781cf40b103d47

Author: MRajcic

storage/ndb/plugin/ha_ndbcluster_cond.cc

@@ -144,7 +144,7 @@ class Ndb_end_cond : public Ndb_item {
 
  public:
   Ndb_end_cond() = default;
-  NDB_ITEM_TYPE get_type() const override final { return NDB_END_COND; }
+  NDB_ITEM_TYPE get_type() const final { return NDB_END_COND; }
 };
 
 class Ndb_func : public Ndb_item {
@@ -160,7 +160,7 @@ class Ndb_func : public Ndb_item {
   Ndb_func(Item_func::Functype func_type, uint no_args)
       : m_func_type(item_func_to_ndb_func(func_type)), m_arg_count(no_args) {}
 
-  NDB_ITEM_TYPE get_type() const override final { return NDB_FUNCTION; }
+  NDB_ITEM_TYPE get_type() const final { return NDB_FUNCTION; }
 
   NDB_FUNC_TYPE get_func_type() const { return m_func_type; }
 
@@ -237,7 +237,7 @@ class Ndb_field : public Ndb_item {
   Ndb_field(Field *field, int column_no)
       : m_field(field), m_column_no(column_no) {}
 
-  NDB_ITEM_TYPE get_type() const override final { return NDB_FIELD; }
+  NDB_ITEM_TYPE get_type() const final { return NDB_FIELD; }
 
   Field *get_field() const { return m_field; }
 
@@ -261,7 +261,7 @@ class Ndb_param : public Ndb_item {
  public:
   Ndb_param(const Item_field *item) : m_item(item), m_param_no(0) {}
 
-  NDB_ITEM_TYPE get_type() const override final { return NDB_PARAM; }
+  NDB_ITEM_TYPE get_type() const final { return NDB_PARAM; }
 
   void set_param_no(uint param_no) const { m_param_no = param_no; }
 

storage/ndb/src/ndbapi/ndb_cluster_connection.cpp

@@ -433,8 +433,8 @@ class NdbApiInternalLogHandler : public LogHandler {
     g_api_internal_log_handler = nullptr;
   }
 
-  virtual void append(const char *pCategory, Logger::LoggerLevel level,
-                      const char *pMsg, time_t now) override {
+  void append(const char *pCategory, Logger::LoggerLevel level,
+              const char *pMsg, time_t now) override {
     {
       if (m_userConsumer) {
         Guard g(m_consumer_mutex);

storage/ndb/test/include/SqlClient.hpp

@@ -52,7 +52,7 @@ class SqlResultSet : public Properties {
   SqlResultSet();
   SqlResultSet(SqlResultSet &) = delete;
   SqlResultSet(SqlResultSet &&) = delete;
-  ~SqlResultSet();
+  ~SqlResultSet() override;
 
   const char *column(const char *col_name);
   std::string_view columnAsString(const char *col_name);

unittest/gunit/bgc_ticket_manager-t.cc

@@ -72,8 +72,8 @@ using ticket_t = binlog::BgcTicket::ValueType;
 class Bgc_ticket_manager_test : public ::testing::Test {
  protected:
   Bgc_ticket_manager_test() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
 TEST_F(Bgc_ticket_manager_test, Several_tickets_test) {

unittest/gunit/containers/integrals_lockfree_queue-t.cc

@@ -175,8 +175,8 @@ class Integrals_lockfree_queue_test : public ::testing::Test {
 
  protected:
   Integrals_lockfree_queue_test() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
 TEST_F(Integrals_lockfree_queue_test, Padding_indexing_test) {

unittest/gunit/dd_pfs-t.cc

@@ -53,21 +53,21 @@ class Dummy_object : public dd::Weak_object_impl_<with_pfs> {
     if (n_children > 0)
       for (auto &child : m_children) child = new Dummy_object<with_pfs, 0>();
   }
-  ~Dummy_object() {
+  ~Dummy_object() override {
     if (n_children > 0)
       for (auto &child : m_children) delete child;
   }
 
   // Dummy definitions needed to make the class non-abstract.
-  virtual void debug_print(dd::String_type &) const {}
-  virtual const dd::Object_table &object_table() const {
+  void debug_print(dd::String_type &) const override {}
+  const dd::Object_table &object_table() const override {
     return dd::tables::Tables::instance();
   }
-  virtual bool validate() const { return false; }
-  virtual bool restore_attributes(const dd::Raw_record &) { return false; }
-  virtual bool store_attributes(dd::Raw_record *) { return false; }
-  virtual bool has_new_primary_key() const { return false; }
-  virtual dd::Object_key *create_primary_key() const { return nullptr; }
+  bool validate() const override { return false; }
+  bool restore_attributes(const dd::Raw_record &) override { return false; }
+  bool store_attributes(dd::Raw_record *) override { return false; }
+  bool has_new_primary_key() const override { return false; }
+  dd::Object_key *create_primary_key() const override { return nullptr; }
 };
 
 /**

unittest/gunit/ddl_rewriter/ddl_rewriter-t.cc

@@ -34,7 +34,7 @@ namespace ddl_rewriter_unittest {
 class DDL_rewriter_test : public ::testing::Test {
  public:
   DDL_rewriter_test() = default;
-  ~DDL_rewriter_test() = default;
+  ~DDL_rewriter_test() override = default;
 };
 
 struct Query_pair {

unittest/gunit/libmysqlgcs/xcom/gcs_logging-t.cc

@@ -32,7 +32,7 @@ class Mock_Logger : public Logger_interface {
     ON_CALL(*this, finalize()).WillByDefault(Return(GCS_OK));
   }
 
-  ~Mock_Logger() = default;
+  ~Mock_Logger() override = default;
   MOCK_METHOD0(initialize, enum_gcs_error());
   MOCK_METHOD0(finalize, enum_gcs_error());
   MOCK_METHOD2(log_event, void(const gcs_log_level_t, const std::string &));

unittest/gunit/libmysqlgcs/xcom/gcs_logging_system-t.cc

@@ -176,7 +176,7 @@ class Wrapper_file_sink : public Sink_interface {
         .WillByDefault(Invoke(m_sink, &Gcs_file_sink::get_information));
   }
 
-  ~Wrapper_file_sink() { delete m_sink; }
+  ~Wrapper_file_sink() override { delete m_sink; }
 
   MOCK_METHOD1(log_event, void(const std::string &message));
   MOCK_METHOD2(log_event, void(const char *message, size_t message_size));

unittest/gunit/libmysqlgcs/xcom/gcs_message_stage_fragmentation-t.cc

@@ -120,7 +120,7 @@ class Mock_gcs_xcom_proxy : public Gcs_xcom_proxy_base {
   /* Mocking fails compilation on Windows. It attempts to copy the std::future
    * which is non-copyable. */
   Gcs_xcom_input_queue::future_reply xcom_input_try_push_and_get_reply(
-      app_data_ptr) {
+      app_data_ptr) override {
     return std::future<std::unique_ptr<Gcs_xcom_input_queue::Reply>>();
   }
   MOCK_METHOD0(xcom_input_try_pop, xcom_input_request_ptr());

unittest/gunit/libmysqlgcs/xcom/gcs_msg_stages-t.cc

@@ -433,18 +433,18 @@ TEST_F(XcomStagesTest, ReceivePacketWithUnknownStage) {
  */
 class Gcs_new_stage_1 : public Gcs_message_stage {
  protected:
-  virtual stage_status skip_apply(
+  stage_status skip_apply(
       uint64_t const &original_payload_size) const override {
     bool result = (original_payload_size != 0);
     return result ? stage_status::apply : stage_status::abort;
   }
 
-  virtual stage_status skip_revert(const Gcs_packet &packet) const override {
+  stage_status skip_revert(const Gcs_packet &packet) const override {
     bool result = (packet.get_payload_length() != 0);
     return result ? stage_status::apply : stage_status::abort;
   }
 
-  virtual std::pair<bool, std::vector<Gcs_packet>> apply_transformation(
+  std::pair<bool, std::vector<Gcs_packet>> apply_transformation(
       Gcs_packet &&packet) override {
     int64_t id = htole64(get_id());
 
@@ -470,8 +470,8 @@ class Gcs_new_stage_1 : public Gcs_message_stage {
     return std::make_pair(false, std::move(packets_out));
   }
 
-  virtual std::pair<Gcs_pipeline_incoming_result, Gcs_packet>
-  revert_transformation(Gcs_packet &&packet) override {
+  std::pair<Gcs_pipeline_incoming_result, Gcs_packet> revert_transformation(
+      Gcs_packet &&packet) override {
 #ifndef NDEBUG
     auto const old_payload_length = packet.get_payload_length();
 #endif
@@ -509,9 +509,9 @@ class Gcs_new_stage_1 : public Gcs_message_stage {
  public:
   explicit Gcs_new_stage_1() : m_id(std::rand()) {}
 
-  virtual ~Gcs_new_stage_1() override = default;
+  ~Gcs_new_stage_1() override = default;
 
-  virtual Stage_code get_stage_code() const override { return my_stage_code(); }
+  Stage_code get_stage_code() const override { return my_stage_code(); }
 
   static Stage_code my_stage_code() { return static_cast<Stage_code>(10); }
 
@@ -555,7 +555,7 @@ class Gcs_new_stage_split_4 : public Gcs_message_stage_split_v2 {
 
   ~Gcs_new_stage_split_4() override = default;
 
-  virtual Stage_code get_stage_code() const override { return my_stage_code(); }
+  Stage_code get_stage_code() const override { return my_stage_code(); }
 
   static Stage_code my_stage_code() { return static_cast<Stage_code>(13); }
 };
@@ -567,7 +567,7 @@ class Gcs_new_stage_lz4_5 : public Gcs_message_stage_lz4 {
 
   ~Gcs_new_stage_lz4_5() override = default;
 
-  virtual Stage_code get_stage_code() const override { return my_stage_code(); }
+  Stage_code get_stage_code() const override { return my_stage_code(); }
 
   static Stage_code my_stage_code() { return static_cast<Stage_code>(14); }
 };

unittest/gunit/libmysqlgcs/xcom/gcs_xcom_communication_interface-t.cc

@@ -149,7 +149,7 @@ class mock_gcs_xcom_proxy : public Gcs_xcom_proxy_base {
   /* Mocking fails compilation on Windows. It attempts to copy the std::future
    * which is non-copyable. */
   Gcs_xcom_input_queue::future_reply xcom_input_try_push_and_get_reply(
-      app_data_ptr) {
+      app_data_ptr) override {
     return std::future<std::unique_ptr<Gcs_xcom_input_queue::Reply>>();
   }
   MOCK_METHOD0(xcom_input_try_pop, xcom_input_request_ptr());

unittest/gunit/libmysqlgcs/xcom/gcs_xcom_control_interface-t.cc

@@ -427,7 +427,7 @@ class mock_gcs_xcom_proxy : public Gcs_xcom_proxy_base {
   /* Mocking fails compilation on Windows. It attempts to copy the std::future
    * which is non-copyable. */
   Gcs_xcom_input_queue::future_reply xcom_input_try_push_and_get_reply(
-      app_data_ptr) {
+      app_data_ptr) override {
     return std::future<std::unique_ptr<Gcs_xcom_input_queue::Reply>>();
   }
   MOCK_METHOD0(xcom_input_try_pop, xcom_input_request_ptr());

unittest/gunit/libmysqlgcs/xcom/gcs_xcom_network_provider-t.cc

@@ -30,9 +30,9 @@ class XComNetworkProviderTest : public GcsBaseTest {
  protected:
   XComNetworkProviderTest() {}
 
-  virtual void SetUp() {}
+  void SetUp() override {}
 
-  virtual void TearDown() {}
+  void TearDown() override {}
 };
 
 TEST_F(XComNetworkProviderTest, StartAndStopTestMissingPort) {

unittest/gunit/libmysqlgcs/xcom/gcs_xcom_network_provider_manager-t.cc

@@ -98,9 +98,9 @@ class XComNetworkProviderManagerTest : public GcsBaseTest {
  protected:
   XComNetworkProviderManagerTest() {}
 
-  virtual void SetUp() {}
+  void SetUp() override {}
 
-  virtual void TearDown() {}
+  void TearDown() override {}
 };
 
 TEST_F(XComNetworkProviderManagerTest, BasicManagerTest) {

unittest/gunit/libmysqlgcs/xcom/gcs_xcom_state_exchange-t.cc

@@ -71,8 +71,9 @@ class mock_gcs_xcom_communication_interface
                               Cargo_type type));
   /* Mocking fails compilation on Windows. It attempts to copy the
    * std::unique_ptr which is non-copyable. */
-  void buffer_incoming_packet(Gcs_packet &&packet,
-                              std::unique_ptr<Gcs_xcom_nodes> &&xcom_nodes) {
+  void buffer_incoming_packet(
+      Gcs_packet &&packet,
+      std::unique_ptr<Gcs_xcom_nodes> &&xcom_nodes) override {
     buffer_incoming_packet_mock(packet, xcom_nodes);
   }
   MOCK_METHOD2(buffer_incoming_packet_mock,
@@ -91,7 +92,8 @@ class mock_gcs_xcom_communication_interface
    std::unique_ptr which is non-copyable.
    */
   Gcs_message *convert_packet_to_message(
-      Gcs_packet &&packet, std::unique_ptr<Gcs_xcom_nodes> &&xcom_nodes) {
+      Gcs_packet &&packet,
+      std::unique_ptr<Gcs_xcom_nodes> &&xcom_nodes) override {
     return convert_packet_to_message_mock(packet, xcom_nodes);
   }
   MOCK_METHOD2(convert_packet_to_message_mock,
@@ -101,8 +103,9 @@ class mock_gcs_xcom_communication_interface
    Mocking fails compilation on Windows. It attempts to copy the
    std::unique_ptr which is non-copyable.
    */
-  void process_user_data_packet(Gcs_packet &&packet,
-                                std::unique_ptr<Gcs_xcom_nodes> &&xcom_nodes) {
+  void process_user_data_packet(
+      Gcs_packet &&packet,
+      std::unique_ptr<Gcs_xcom_nodes> &&xcom_nodes) override {
     process_user_data_packet_mock(packet, xcom_nodes);
   }
   MOCK_METHOD2(process_user_data_packet_mock,
@@ -114,7 +117,7 @@ class mock_gcs_xcom_communication_interface
    which is non-copyable.
    */
   std::pair<bool, std::future<void>> set_protocol_version(
-      Gcs_protocol_version new_version) {
+      Gcs_protocol_version new_version) override {
     auto future = std::async([this, new_version]() {
       return set_protocol_version_mock(new_version);
     });
@@ -135,7 +138,7 @@ class mock_gcs_xcom_communication_interface
                void(std::shared_ptr<Network_provider> provider));
   MOCK_METHOD0(get_incoming_connections_protocol, enum_transport_protocol());
 
-  virtual Gcs_message_pipeline &get_msg_pipeline() { return m_msg_pipeline; }
+  Gcs_message_pipeline &get_msg_pipeline() override { return m_msg_pipeline; }
 
  private:
   Gcs_message_pipeline m_msg_pipeline;

unittest/gunit/libmysqlgcs/xcom/gcs_xcom_xcom_base-t.cc

@@ -49,7 +49,7 @@ class XcomBase : public GcsBaseTest {
     auto xcom_network_provider = std::make_shared<Xcom_network_provider>();
     net_manager.add_network_provider(xcom_network_provider);
   }
-  ~XcomBase() { ::deinit_cache(); }
+  ~XcomBase() override { ::deinit_cache(); }
 };
 
 TEST_F(XcomBase, XcomSendClientAppDataUpgradeScenario) {

unittest/gunit/locks/shared_spin_lock-t.cc

@@ -36,8 +36,8 @@ namespace unittests {
 class Shared_spin_lock_test : public ::testing::Test {
  protected:
   Shared_spin_lock_test() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
 TEST_F(Shared_spin_lock_test, Lock_unlock_test) {

unittest/gunit/memory/aligned_atomic-t.cc

@@ -50,8 +50,8 @@ using Aligned_atomic_accessor_ut =
 class AlignedAtomicTest : public ::testing::Test {
  protected:
   AlignedAtomicTest() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
 TEST_F(AlignedAtomicTest, Class_template_test) {

unittest/gunit/memory/ref_ptr-t.cc

@@ -37,8 +37,8 @@ namespace unittests {
 class Ref_ptr_test : public ::testing::Test {
  protected:
   Ref_ptr_test() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
 TEST_F(Ref_ptr_test, Class_template_test) {

unittest/gunit/memory/unique_ptr-t.cc

@@ -33,8 +33,8 @@ namespace unittests {
 class Unique_ptr_test : public ::testing::Test {
  protected:
   Unique_ptr_test() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 };
 
 TEST_F(Unique_ptr_test, Array_template_test) {

unittest/gunit/rpl_commit_order_queue-t.cc

@@ -39,8 +39,8 @@ namespace unittests {
 class Rpl_commit_order_queue_test : public ::testing::Test {
  protected:
   Rpl_commit_order_queue_test() = default;
-  virtual void SetUp() {}
-  virtual void TearDown() {}
+  void SetUp() override {}
+  void TearDown() override {}
 
   std::atomic<bool> m_go{false};
   std::atomic<size_t> m_count{0};