Bug#35307859: Fix clang-tidy warnings related to const correctness

Resolve a large number of instances of the following clang-tidy warning:
[misc-const-correctness]
warning: variable 't' of type 'double' can be declared 'const'
https://clang.llvm.org/extra/clang-tidy/checks/misc/const-correctness.html

Local variables not being modified after initialization are now declared
const. The increases type safety and prevents you from accidentally
modifying something you didn’t expect would be modified. This info can
also help compiler to make better code optimization decisions.

Change-Id: Id478cb2898ed0332629e59912d6f295658ce3aa6

Author: MRajcic

client/base/abstract_options_provider.cc

@@ -146,7 +146,7 @@ void Abstract_options_provider::notify_option_name_changed(I_option *source,
     this->m_name_usage.erase(this->m_name_usage.find(old_name));
   }
 
-  string new_name = source->get_my_option().name;
+  const string new_name = source->get_my_option().name;
 
   // Try to find existing option with that name.
   map<string, I_option *>::iterator name_item =
@@ -178,15 +178,15 @@ void Abstract_options_provider::notify_option_optid_changed(I_option *source,
     this->m_optid_usage.erase(this->m_optid_usage.find(old_optid));
   }
 
-  uint32 new_optid = source->get_my_option().id;
+  const uint32 new_optid = source->get_my_option().id;
 
   // Try to find existing option with that optid.
   map<uint32, I_option *>::iterator optid_item =
       this->m_optid_usage.find(new_optid);
 
   // Report error if already used.
   if (optid_item != this->m_optid_usage.end()) {
-    string name = source->get_my_option().name;
+    const string name = source->get_my_option().name;
 
     std::cerr << "Cannot register new option \"" << name
               << "\" as it collides with existing one with following name \""

client/base/abstract_program.cc

@@ -69,8 +69,8 @@ void Abstract_program::run(int argc, char **argv) {
                              Message_type_error));
   my_getopt_use_args_separator = false;
 
-  int ho_error = handle_options(&argc, &argv, this->get_options_array(),
-                                Abstract_program::callback_option_parsed);
+  const int ho_error = handle_options(&argc, &argv, this->get_options_array(),
+                                      Abstract_program::callback_option_parsed);
   if (ho_error != 0) {
     this->error(Message_data(ho_error, "Error during handling options",
                              Message_type_error));

client/base/help_options.cc

@@ -80,7 +80,7 @@ void Mysql::Tools::Base::Options::Help_options::print_usage() {
     copyright = ORACLE_WELCOME_COPYRIGHT_NOTICE(COPYRIGHT_NOTICE_CURRENT_YEAR);
   } else {
 #define FIRST_YEAR_CONSTANT "$first_year$"
-    string first_year_constant_str = FIRST_YEAR_CONSTANT;
+    const string first_year_constant_str = FIRST_YEAR_CONSTANT;
 
     copyright = ORACLE_WELCOME_COPYRIGHT_NOTICE(FIRST_YEAR_CONSTANT);
     copyright =

client/base/mysql_query_runner.cc

@@ -93,7 +93,7 @@ int64 Mysql_query_runner::run_query(
     std::string query, std::function<int64(const Row &)> *result_callback) {
   Mysql_query_runner copy(*this);
   copy.add_result_callback(result_callback);
-  int64 result = copy.run_query(query);
+  const int64 result = copy.run_query(query);
   delete result_callback;
   copy.m_result_callbacks.clear();
   return result;
@@ -113,7 +113,7 @@ int64 Mysql_query_runner::run_query(std::string query) {
                          Message_type_error);
     return this->report_message(message);
   }
-  uint64 result = this->run_query_unguarded(query);
+  const uint64 result = this->run_query_unguarded(query);
   *m_is_processing = false;
 
   return result;
@@ -140,13 +140,13 @@ int64 Mysql_query_runner::run_query_unguarded(string query) {
         }
       }
 
-      unsigned int columns = mysql_field_count(m_connection);
+      const unsigned int columns = mysql_field_count(m_connection);
       Row *processed_row = new Row(results, columns, row);
 
       vector<std::function<int64(const Row &)> *>::reverse_iterator it;
       for (it = m_result_callbacks.rbegin(); it != m_result_callbacks.rend();
            ++it) {
-        int64 callback_result = (**it)(*processed_row);
+        const int64 callback_result = (**it)(*processed_row);
         if (callback_result != 0) {
           mysql_free_result(results);
           return callback_result;
@@ -176,7 +176,7 @@ int64 Mysql_query_runner::run_query_unguarded(string query) {
       break;
     }
 
-    unsigned int columns = mysql_field_count(m_connection);
+    const unsigned int columns = mysql_field_count(m_connection);
     Row *processed_row = new Row(results, columns, row);
 
     Warning_data warning(
@@ -199,7 +199,7 @@ int64 Mysql_query_runner::report_mysql_error() {
 int64 Mysql_query_runner::report_message(Message_data &message) {
   for (auto it = m_message_callbacks.rbegin(); it != m_message_callbacks.rend();
        it++) {
-    int64 callback_result = (*it->first)(message);
+    const int64 callback_result = (*it->first)(message);
     if (callback_result < 0) {
       return 0;
     } else if (callback_result != 0) {
@@ -263,11 +263,11 @@ void Mysql_query_runner::append_escape_string(std::string *destination_string,
 void Mysql_query_runner::append_escape_string(std::string *destination_string,
                                               const char *original,
                                               size_t original_length) {
-  size_t start_lenght = destination_string->size();
-  size_t required_capacity = start_lenght + original_length * 2 + 1;
+  const size_t start_lenght = destination_string->size();
+  const size_t required_capacity = start_lenght + original_length * 2 + 1;
   destination_string->resize(required_capacity);
 
-  int length = mysql_real_escape_string_quote(
+  const int length = mysql_real_escape_string_quote(
       m_connection, &((*destination_string)[0]) + start_lenght, original,
       (ulong)original_length, '"');
   destination_string->resize(start_lenght + length);
@@ -276,12 +276,12 @@ void Mysql_query_runner::append_escape_string(std::string *destination_string,
 void Mysql_query_runner::append_hex_string(std::string *destination_string,
                                            const char *original,
                                            size_t original_length) {
-  size_t start_lenght = destination_string->size();
-  size_t required_capacity = start_lenght + original_length * 2 + 1;
+  const size_t start_lenght = destination_string->size();
+  const size_t required_capacity = start_lenght + original_length * 2 + 1;
   destination_string->resize(required_capacity);
 
-  int length = mysql_hex_string(&((*destination_string)[0]) + start_lenght,
-                                original, original_length);
+  const int length = mysql_hex_string(
+      &((*destination_string)[0]) + start_lenght, original, original_length);
   destination_string->resize(start_lenght + length);
 }
 
@@ -351,7 +351,7 @@ const char *Mysql_query_runner::Row::get_buffer(std::size_t index,
     start = m_buffer_starts[start_index];
   }
 
-  std::size_t end = m_buffer_starts[index + 1];
+  const std::size_t end = m_buffer_starts[index + 1];
   length = (end - start - 1);
   return &m_buffer[start];
 }

client/check/mysqlcheck.cc

@@ -304,7 +304,7 @@ static void usage(void) {
 extern "C" {
 static bool get_one_option(int optid, const struct my_option *opt,
                            char *argument) {
-  int orig_what_to_do = what_to_do;
+  const int orig_what_to_do = what_to_do;
 
   switch (optid) {
     case 'a':
@@ -395,7 +395,7 @@ static int get_options(int *argc, char ***argv, MEM_ROOT *alloc) {
   my_getopt_use_args_separator = false;
 
   if (!what_to_do) {
-    size_t pnlen = strlen(my_progname);
+    const size_t pnlen = strlen(my_progname);
 
     if (pnlen < 6) /* name too short */
       what_to_do = DO_CHECK;

client/check/mysqlcheck_core.cc

@@ -280,8 +280,8 @@ static void print_result() {
   prev_alter[0] = 0;
 
   while ((row = mysql_fetch_row(res))) {
-    int changed = strcmp(prev, row[0]);
-    bool status = !strcmp(row[2], "status");
+    const int changed = strcmp(prev, row[0]);
+    const bool status = !strcmp(row[2], "status");
 
     if (status) {
       /*

client/client_query_attributes.cc

@@ -34,7 +34,7 @@ bool client_query_attributes::push_param(const char *name, const char *value) {
   if (count >= max_count) return true;
   names[count] = my_strdup(PSI_NOT_INSTRUMENTED, name, MYF(0));
   memset(&values[count], 0, sizeof(MYSQL_BIND));
-  unsigned val_len = strlen(value);
+  const unsigned val_len = strlen(value);
   values[count].buffer = my_malloc(PSI_NOT_INSTRUMENTED, val_len + 1, MYF(0));
   if (val_len) memcpy(values[count].buffer, value, val_len);
   ((unsigned char *)values[count].buffer)[val_len] = 0;
@@ -47,7 +47,7 @@ bool client_query_attributes::push_param(const char *name, const char *value) {
 int client_query_attributes::set_params(MYSQL *mysql) {
   if (count == 0) return 0;
 
-  int rc = mysql_bind_param(mysql, count, values, names);
+  const int rc = mysql_bind_param(mysql, count, values, names);
   return rc;
 }
 

client/json_binlog_main.cc

@@ -34,28 +34,28 @@
 int main() {
   json_binary::Value value = json_binary::parse_binary(nullptr, 0);
 
-  bool is_valid = value.is_valid();
-  json_binary::Value::enum_type enum_type = value.type();
+  const bool is_valid = value.is_valid();
+  const json_binary::Value::enum_type enum_type = value.type();
 
   value = json_binary::Value(json_binary::Value::OBJECT, nullptr, 0, 1, false);
 
-  json_binary::Value elt1 = value.element(1);
-  json_binary::Value key1 = value.key(1);
+  const json_binary::Value elt1 = value.element(1);
+  const json_binary::Value key1 = value.key(1);
 
-  size_t sz1 = value.lookup_index("foo", 3);
-  size_t sz2 = value.lookup_index(std::string("foo"));
+  const size_t sz1 = value.lookup_index("foo", 3);
+  const size_t sz2 = value.lookup_index(std::string("foo"));
 
-  bool has_space = value.has_space(0, 0, nullptr);
+  const bool has_space = value.has_space(0, 0, nullptr);
 
-  json_binary::Value null_value =
+  const json_binary::Value null_value =
       json_binary::Value(json_binary::Value::LITERAL_NULL);
 
-  json_binary::Value int_value =
+  const json_binary::Value int_value =
       json_binary::Value(json_binary::Value::INT, 42);
 
-  json_binary::Value double_value = json_binary::Value(0.0);
+  const json_binary::Value double_value = json_binary::Value(0.0);
 
-  json_binary::Value string_value = json_binary::Value("foo", 3);
+  const json_binary::Value string_value = json_binary::Value("foo", 3);
 
   std::string string_buf;
   string_value.to_std_string(&string_buf, [] { assert(false); });

client/json_client_library_main.cc

@@ -43,7 +43,7 @@ int main() {
 
   // Make sure Json_wrapper::seek is visible
   Json_wrapper_vector hits(PSI_NOT_INSTRUMENTED);
-  bool need_only_one{false};
+  const bool need_only_one{false};
   const char *json_path = R"($**."512")";
   Json_path path(PSI_NOT_INSTRUMENTED);
   size_t bad_index;
@@ -62,15 +62,15 @@ int main() {
 
   // Make sure Json_dom::parse is visible and error handling works
   {
-    std::string json{"[{\"key\":123},146]"};
+    const std::string json{"[{\"key\":123},146]"};
     Json_dom_ptr dom(Json_dom::parse(
         json.c_str(), json.length(),
         [](const char *, size_t) { assert(false); }, [] { assert(false); }));
     if (dom != nullptr) std::cout << "1. success" << std::endl;
   }
 
   {
-    std::string json{
+    const std::string json{
         "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["
         R"([[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{"key":123}]]]]]]]]]]]]]]]]]]]]]]]]]])"
         "]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
@@ -86,7 +86,7 @@ int main() {
   }
 
   {
-    std::string json{"[&&"};
+    const std::string json{"[&&"};
     Json_dom_ptr dom(Json_dom::parse(
         json.c_str(), json.length(),
         [](const char *err_mesg, size_t err_code) {

client/logger.cc

@@ -33,11 +33,11 @@ using namespace std;
 
 ostream &operator<<(ostream &os, const Datetime &) {
   const char format[] = "%Y-%m-%d %X";
-  time_t t(time(nullptr));
-  tm tm(*localtime(&t));
+  const time_t t(time(nullptr));
+  const tm tm(*localtime(&t));
 
   const size_t date_length{50};
-  std::unique_ptr<char[]> date{new char[date_length]};
+  const std::unique_ptr<char[]> date{new char[date_length]};
   strftime(date.get(), date_length, format, &tm);
 
   os << date.get() << " ";
@@ -49,7 +49,7 @@ ostream &operator<<(ostream &os, const Gen_spaces &gen) {
 }
 
 int Log::Log_buff::sync() {
-  string sout(str());
+  const string sout(str());
   if (m_enabled && sout.length() > 0) {
     m_os << Datetime() << "[" << m_logc << "]"
          << Gen_spaces(8 - m_logc.length()) << sout;