perf: use T&& instead of const T&&

We were using const T&& instead of T&& in copy and assignment
operators.  As part of the commit, I also try to use default as much
as possible.

Thanks to Enea Zaffanella to point out the problem with move operators

include/crab/cfg/cfg.hpp

@@ -3134,10 +3134,6 @@ class function_decl {
       : m_func_name(o.m_func_name), m_inputs(o.m_inputs),
         m_outputs(o.m_outputs) {}
 
-  function_decl(const this_type &&o)
-      : m_func_name(std::move(o.m_func_name)), m_inputs(std::move(o.m_inputs)),
-        m_outputs(std::move(o.m_outputs)) {}
-
   this_type &operator=(const this_type &o) {
     if (this != &o) {
       m_func_name = o.m_func_name;
@@ -3147,13 +3143,9 @@ class function_decl {
     return *this;
   }
 
-  this_type &operator=(const this_type &&o) {
-    m_func_name = std::move(o.m_func_name);
-    m_inputs = std::move(o.m_inputs);
-    m_outputs = std::move(o.m_outputs);
-    return *this;
-  }
-
+  function_decl(this_type &&o) = default;
+  this_type &operator=(this_type &&o) = default;
+
   bool operator==(const this_type &o) const {
     if (m_func_name != o.m_func_name) {
       return false;

include/crab/domains/apron_domains.hpp

@@ -705,18 +705,13 @@ class apron_domain final
             apPtr(get_man(), (isBot ? ap_abstract0_bottom(get_man(), 0, 0)
                                     : ap_abstract0_top(get_man(), 0, 0)))) {}
 
-  ~apron_domain() {}
-
   apron_domain(const apron_domain_t &o)
       : m_apstate(
             apPtr(get_man(), ap_abstract0_copy(get_man(), &*(o.m_apstate)))),
         m_var_map(o.m_var_map) {
     APRON_DOMAIN_SCOPED_STATS(".copy");
   }
 
-  apron_domain(apron_domain_t &&o)
-      : m_apstate(std::move(o.m_apstate)), m_var_map(std::move(o.m_var_map)) {}
-
   apron_domain_t &operator=(const apron_domain_t &o) {
     APRON_DOMAIN_SCOPED_STATS(".copy");
     if (this != &o) {
@@ -727,13 +722,9 @@ class apron_domain final
     return *this;
   }
 
-  apron_domain_t &operator=(apron_domain_t &&o) {
-    if (this != &o) {
-      m_apstate = std::move(o.m_apstate);
-      m_var_map = std::move(o.m_var_map);
-    }
-    return *this;
-  }
+  apron_domain(apron_domain_t&& o) = default;
+  apron_domain_t &operator=(apron_domain_t &&o) = default;
+  ~apron_domain() = default;
 
   apron_domain_t make_top() const override {
     apron_domain_t out(false);

include/crab/domains/array_adaptive.hpp

@@ -358,11 +358,11 @@ class offset_map_t {
 
   offset_map_t(const offset_map_t &o);
 
-  offset_map_t(const offset_map_t &&o);
+  offset_map_t(offset_map_t &&o);
 
   offset_map_t &operator=(const offset_map_t &o);
 
-  offset_map_t &operator=(const offset_map_t &&o);
+  offset_map_t &operator=(offset_map_t &&o);
 
   bool empty() const;
 
@@ -1012,13 +1012,6 @@ class array_adaptive_domain final
       do_sanity_checks();
     }
 
-    array_state(const array_state &&o)
-        : m_is_smashed(std::move(o.m_is_smashed)),
-          m_element_sz(std::move(o.m_element_sz)),
-          m_offset_map(std::move(o.m_offset_map)) {
-      do_sanity_checks();
-    }
-
     array_state &operator=(const array_state &o) {
       if (this != &o) {
         m_is_smashed = o.m_is_smashed;
@@ -1029,15 +1022,8 @@ class array_adaptive_domain final
       return *this;
     }
 
-    array_state &operator=(const array_state &&o) {
-      if (this != &o) {
-        m_is_smashed = std::move(o.m_is_smashed);
-        m_element_sz = std::move(o.m_element_sz);
-        m_offset_map = std::move(o.m_offset_map);
-      }
-      do_sanity_checks();
-      return *this;
-    }
+    array_state(array_state &&o) = default;
+    array_state &operator=(array_state &&o) = default;
 
     /*** begin mergeable_map API ***/
     array_state join(const variable_t &v, const array_state &o,
@@ -1255,22 +1241,15 @@ class array_adaptive_domain final
 
     array_state_map_t(const array_state_map_t &o) : m_tree(o.m_tree) {}
 
-    array_state_map_t(const array_state_map_t &&o)
-        : m_tree(std::move(o.m_tree)) {}
-
     array_state_map_t &operator=(const array_state_map_t &o) {
       if (this != &o) {
         m_tree = o.m_tree;
       }
       return *this;
     }
 
-    array_state_map_t &operator=(const array_state_map_t &&o) {
-      if (this != &o) {
-        m_tree = std::move(o.m_tree);
-      }
-      return *this;
-    }
+    array_state_map_t(array_state_map_t&& o) = default;
+    array_state_map_t& operator=(array_state_map_t&& o) = default;
 
     iterator begin() const { return m_tree.begin(); }
 
@@ -1727,10 +1706,6 @@ class array_adaptive_domain final
     ARRAY_ADAPTIVE_DOMAIN_SCOPED_STATS(".copy");
   }
 
-  array_adaptive_domain(const array_adaptive_domain_t &&other)
-      : m_base_dom(std::move(other.m_base_dom)),
-        m_array_map(std::move(other.m_array_map)),
-        m_cell_ghost_man(std::move(other.m_cell_ghost_man)) {}
 
   array_adaptive_domain_t &operator=(const array_adaptive_domain_t &other) {
     ARRAY_ADAPTIVE_DOMAIN_SCOPED_STATS(".copy");
@@ -1742,14 +1717,8 @@ class array_adaptive_domain final
     return *this;
   }
 
-  array_adaptive_domain_t &operator=(const array_adaptive_domain_t &&other) {
-    if (this != &other) {
-      m_base_dom = std::move(other.m_base_dom);
-      m_array_map = std::move(other.m_array_map);
-      m_cell_ghost_man = std::move(other.m_cell_ghost_man);
-    }
-    return *this;
-  }
+  array_adaptive_domain(array_adaptive_domain_t &&other) = default;
+  array_adaptive_domain_t &operator=(array_adaptive_domain_t &&other) = default;
 
   bool is_bottom() const override { return (m_base_dom.is_bottom()); }
 
@@ -1781,7 +1750,7 @@ class array_adaptive_domain final
     }
   }
 
-  bool operator==(array_adaptive_domain_t other) {
+  bool operator==(const array_adaptive_domain_t &other) {
     return (m_base_dom <= other.m_base_dom && other.m_base_dom <= m_base_dom);
   }
 

include/crab/domains/array_smashing.hpp

@@ -246,7 +246,6 @@ class array_smashing final
     ARRAY_SMASHING_DOMAIN_SCOPED_STATS(".copy");
   }
 
-  array_smashing(array_smashing_t &&other) = default;
 
   array_smashing_t &operator=(const array_smashing_t &other) {
     ARRAY_SMASHING_DOMAIN_SCOPED_STATS(".copy");
@@ -257,6 +256,7 @@ class array_smashing final
     return *this;
   }
 
+  array_smashing(array_smashing_t &&other) = default;  
   array_smashing_t &operator=(array_smashing_t &&other) = default;
 
   bool is_bottom() const override { return m_base_dom.is_bottom(); }

include/crab/domains/boxes.hpp

@@ -810,9 +810,7 @@ class boxes_domain final
         m_ldd(lddPtr(get_ldd_man(), &(*other.m_ldd))) {
     BOXES_DOMAIN_SCOPED_STATS(".copy");
   }
-
-  boxes_domain(boxes_domain_t &&other) : m_ldd(std::move(other.m_ldd)) {}
-
+
   boxes_domain_t &operator=(const boxes_domain_t &other) {
     BOXES_DOMAIN_SCOPED_STATS(".copy");
     if (this != &other) {
@@ -822,6 +820,12 @@ class boxes_domain final
     return *this;
   }
 
+  boxes_domain(boxes_domain_t &&other) : m_ldd(std::move(other.m_ldd)) {}
+  boxes_domain_t &operator=(boxes_domain_t &&other) {
+    m_ldd = std::move(other.m_ldd);
+    return *this;
+  }
+
   bool is_bottom() const override {
     return &*m_ldd == Ldd_GetFalse(get_ldd_man());
   }

include/crab/domains/combined_congruences.hpp

@@ -131,12 +131,15 @@ class numerical_congruence_domain final
       : m_product(other.m_product) {}
 
   rnc_domain_t &operator=(const rnc_domain_t &other) {
-    if (this != &other)
+    if (this != &other) {
       m_product = other.m_product;
-
+    }
     return *this;
   }
 
+  numerical_congruence_domain(rnc_domain_t &&other) = default;
+  rnc_domain_t &operator=(rnc_domain_t &&other) = default;
+
   bool is_bottom() const override { return m_product.is_bottom(); }
 
   bool is_top() const override { return m_product.is_top(); }

include/crab/domains/combined_domains.hpp

@@ -353,20 +353,18 @@ class reduced_domain_product2 final
   reduced_domain_product2(const reduced_domain_product2_t &other)
     : m_product(other.m_product) {}
 
-  reduced_domain_product2(const reduced_domain_product2_t &&other)
+  reduced_domain_product2(reduced_domain_product2_t &&other) 
       : m_product(std::move(other.m_product)) {}
 
   reduced_domain_product2_t &operator=(const reduced_domain_product2_t &other) {
-    if (this != &other)
+    if (this != &other) {
       m_product = other.m_product;
+    }
     return *this;
   }
 
-  reduced_domain_product2_t &operator=(const reduced_domain_product2_t &&other) {
-    if (this != &other)
-      m_product = std::move(other.m_product);
-    return *this;
-  }
+  reduced_domain_product2_t&
+  operator=(reduced_domain_product2_t&& o) = default;
 
   bool is_bottom() const override { return m_product.is_bottom(); }
 
@@ -1186,10 +1184,8 @@ class reduced_numerical_domain_product2 final
     : m_product(other.m_product) {}
 
   reduced_numerical_domain_product2(
-      reduced_numerical_domain_product2_t &&other)
-    : m_product(std::move(other.m_product)) {}
+      reduced_numerical_domain_product2_t&& other) = default;
 
-
   reduced_numerical_domain_product2_t &
   operator=(const reduced_numerical_domain_product2_t &other) {
     if (this != &other) {
@@ -1198,14 +1194,9 @@ class reduced_numerical_domain_product2 final
     return *this;
   }
 
-  reduced_numerical_domain_product2_t &
-  operator=(reduced_numerical_domain_product2_t &&other) {
-    if (this != &other) {
-      m_product = std::move(other.m_product);
-    }
-    return *this;
-  }
-
+  reduced_numerical_domain_product2_t&
+  operator=(reduced_numerical_domain_product2_t&& other) = default;
+
   bool is_bottom() const override { return m_product.is_bottom(); }
 
   bool is_top() const override { return m_product.is_top(); }

include/crab/domains/constant_domain.hpp

@@ -177,7 +177,6 @@ class constant_domain final : public crab::domains::abstract_domain_api<
     CONSTANT_DOMAIN_SCOPED_STATS(".copy");
   }
 
-  constant_domain(constant_domain_t &&e) : m_env(std::move(e.m_env)) {}
 
   constant_domain_t &operator=(const constant_domain_t &o) {
     CONSTANT_DOMAIN_SCOPED_STATS(".copy");
@@ -187,12 +186,8 @@ class constant_domain final : public crab::domains::abstract_domain_api<
     return *this;
   }
 
-  constant_domain_t &operator=(constant_domain_t &&o) {
-    if (this != &o) {
-      m_env = std::move(o.m_env);
-    }
-    return *this;
-  }
+  constant_domain(constant_domain_t &&o) = default;  
+  constant_domain_t &operator=(constant_domain_t &&o) = default;
 
   constant_t get_constant(const variable_t &v) const { return m_env.at(v); }
 

include/crab/domains/dis_intervals.hpp

@@ -1149,6 +1149,9 @@ class dis_interval_domain final
     return *this;
   }
 
+  dis_interval_domain(dis_interval_domain_t &&o) = default;
+  dis_interval_domain_t &operator=(dis_interval_domain_t &&o) = default;
+
   bool is_bottom() const override { return this->_env.is_bottom(); }
 
   bool is_top() const override { return this->_env.is_top(); }

include/crab/domains/elina_domains.hpp

@@ -937,9 +937,6 @@ class elina_domain final
     ELINA_DOMAIN_SCOPED_STATS(".copy");
   }
 
-  elina_domain(elina_domain_t &&o)
-      : m_apstate(std::move(o.m_apstate)), m_var_map(std::move(o.m_var_map)) {}
-
   elina_domain_t &operator=(const elina_domain_t &o) {
     ELINA_DOMAIN_SCOPED_STATS(".copy");
     if (this != &o) {
@@ -950,13 +947,8 @@ class elina_domain final
     return *this;
   }
 
-  elina_domain_t &operator=(elina_domain_t &&o) {
-    if (this != &o) {
-      m_apstate = std::move(o.m_apstate);
-      m_var_map = std::move(o.m_var_map);
-    }
-    return *this;
-  }
+  elina_domain(elina_domain_t &&o) = default;  
+  elina_domain_t &operator=(elina_domain_t &&o) = default;
 
   elina_domain_t make_top() const override {
     elina_domain_t out(false);