Use noexcept more. (#7058)

src/ast/recfun_decl_plugin.cpp

@@ -602,15 +602,6 @@ namespace recfun {
         m_args.append(n->get_num_args(), n->get_args());
     }
 
-    case_expansion::case_expansion(case_expansion const & from)
-        : m_lhs(from.m_lhs),
-          m_def(from.m_def),
-          m_args(from.m_args) {}
-    case_expansion::case_expansion(case_expansion && from)
-        : m_lhs(from.m_lhs),
-          m_def(from.m_def),
-          m_args(std::move(from.m_args)) {}
-
     std::ostream& case_expansion::display(std::ostream & out) const {
         return out << "case_exp(" << m_lhs << ")";
     }

src/ast/recfun_decl_plugin.h

@@ -301,8 +301,6 @@ namespace recfun {
         recfun::def *       m_def;
         expr_ref_vector     m_args;
         case_expansion(recfun::util& u, app * n);
-        case_expansion(case_expansion const & from);
-        case_expansion(case_expansion && from);
         std::ostream& display(std::ostream& out) const;
     };
 
@@ -323,10 +321,6 @@ namespace recfun {
         }
         body_expansion(app_ref & pred, recfun::case_def const & d, expr_ref_vector & args) : 
             m_pred(pred), m_cdef(&d), m_args(args) {}
-        body_expansion(body_expansion const & from): 
-            m_pred(from.m_pred), m_cdef(from.m_cdef), m_args(from.m_args) {}
-        body_expansion(body_expansion && from) noexcept :
-            m_pred(from.m_pred), m_cdef(from.m_cdef), m_args(std::move(from.m_args)) {}
 
         std::ostream& display(std::ostream& out) const;
     };

src/math/dd/dd_pdd.h

@@ -503,7 +503,7 @@ namespace dd {
         unsigned max_pow2_divisor() const { return m->max_pow2_divisor(root); }
         unsigned_vector const& free_vars() const { return m->free_vars(*this); }
 
-        void swap(pdd& other) { VERIFY_EQ(m, other.m); std::swap(root, other.root); }
+        void swap(pdd& other) noexcept { VERIFY_EQ(m, other.m); std::swap(root, other.root); }
 
         pdd_iterator begin() const;
         pdd_iterator end() const;
@@ -547,7 +547,7 @@ namespace dd {
     inline pdd& operator-=(pdd & p, rational const& q) { p = p - q; return p; }
     inline pdd& operator+=(pdd & p, rational const& q) { p = p + q; return p; }
 
-    inline void swap(pdd& p, pdd& q) { p.swap(q); }
+    inline void swap(pdd& p, pdd& q) noexcept { p.swap(q); }
 
     std::ostream& operator<<(std::ostream& out, pdd const& b);
 

src/math/lp/lp_core_solver_base.h

@@ -517,7 +517,7 @@ public:
 
     
     template <typename K>
-    static void swap(vector<K> &v, unsigned i, unsigned j) {
+    static void swap(vector<K> &v, unsigned i, unsigned j) noexcept {
         auto t = v[i];
         v[i] = v[j];
         v[j] = t;

src/math/polynomial/algebraic_numbers.cpp

@@ -358,7 +358,7 @@ namespace algebraic_numbers {
             return a.to_algebraic()->m_p_sz - 1;
         }
 
-        void swap(numeral & a, numeral & b) {
+        void swap(numeral & a, numeral & b) noexcept {
             std::swap(a.m_cell, b.m_cell);
         }
 
@@ -2935,7 +2935,7 @@ namespace algebraic_numbers {
         return m_imp->to_rational(const_cast<numeral&>(a), r);
     }
 
-    void manager::swap(numeral & a, numeral & b) {
+    void manager::swap(numeral & a, numeral & b) noexcept {
         return m_imp->swap(a, b);
     }
 

src/math/polynomial/algebraic_numbers.h

@@ -129,7 +129,7 @@ namespace algebraic_numbers {
         void set(numeral & a, mpq const & n);
         void set(numeral & a, numeral const & n);
 
-        void swap(numeral & a, numeral & b);
+        void swap(numeral & a, numeral & b) noexcept;
 
         /**
            \brief Store in b an integer value smaller than 'a'.

src/math/polynomial/polynomial.cpp

@@ -447,7 +447,7 @@ namespace polynomial {
         }
     };
 
-    inline void swap(monomial * & m1, monomial * & m2) { std::swap(m1, m2); }
+    inline void swap(monomial * & m1, monomial * & m2) noexcept { std::swap(m1, m2); }
 
     typedef chashtable<monomial*, monomial::hash_proc, monomial::eq_proc> monomial_table;
 

src/math/polynomial/upolynomial.cpp

@@ -126,7 +126,7 @@ namespace upolynomial {
         m_factors[i].swap(p);
     }
 
-    void core_manager::factors::swap(factors & other) {
+    void core_manager::factors::swap(factors & other) noexcept {
         m_factors.swap(other.m_factors);
         m_degrees.swap(other.m_degrees);
         nm().swap(m_constant, other.m_constant);

src/math/polynomial/upolynomial.h

@@ -89,7 +89,7 @@ namespace upolynomial {
             void push_back_swap(numeral_vector & p, unsigned degree);
             
             void swap_factor(unsigned i, numeral_vector & p);
-            void swap(factors & other);
+            void swap(factors & other) noexcept;
             void multiply(numeral_vector & out) const; 
             
             void display(std::ostream & out) const;

src/math/polynomial/upolynomial_factorization_int.h

@@ -85,7 +85,7 @@ namespace upolynomial {
 
         unsigned max_degree() const { return m_set.size() - 1; }
 
-        void swap(factorization_degree_set & other) {
+        void swap(factorization_degree_set & other) noexcept {
             m_set.swap(other.m_set);
         }
 

src/math/realclosure/mpz_matrix.h

@@ -50,7 +50,7 @@ public:
         SASSERT(j < n); 
         return a_ij[i*n + j]; }
     mpz & operator()(unsigned i, unsigned j) { SASSERT(i < m); SASSERT(j < n); return a_ij[i*n + j]; }
-    void swap(mpz_matrix & B) { std::swap(m, B.m); std::swap(n, B.n); std::swap(a_ij, B.a_ij); }
+    void swap(mpz_matrix & B) noexcept { std::swap(m, B.m); std::swap(n, B.n); std::swap(a_ij, B.a_ij); }
     mpz * row(unsigned i) const { SASSERT(i < m); return a_ij + i*n; }
 };
 
@@ -136,7 +136,7 @@ public:
     mpz_matrix const & get() const { return A; }
     mpz_matrix & get() { return A; }
 
-    void swap(mpz_matrix & B) { A.swap(B); }
+    void swap(mpz_matrix & B) noexcept { A.swap(B); }
 
     void set(unsigned i, unsigned j, mpz const & v) { nm().set(A(i, j), v); }
     void set(unsigned i, unsigned j, int v) { nm().set(A(i, j), v); }

src/math/realclosure/realclosure.cpp

@@ -135,7 +135,7 @@ namespace realclosure {
     typedef interval_manager<mpbq_config> mpbqi_manager;
     typedef mpbqi_manager::interval       mpbqi;
 
-    void swap(mpbqi & a, mpbqi & b) {
+    void swap(mpbqi & a, mpbqi & b) noexcept {
         swap(a.m_lower, b.m_lower);
         swap(a.m_upper, b.m_upper);
         std::swap(a.m_lower_inf, b.m_lower_inf);
@@ -2534,7 +2534,7 @@ namespace realclosure {
             return depends_on_infinitesimals(a.m_value);
         }
 
-        static void swap(mpbqi & a, mpbqi & b) {
+        static void swap(mpbqi & a, mpbqi & b) noexcept {
             realclosure::swap(a, b);
         }
 
@@ -6313,7 +6313,7 @@ namespace realclosure {
         m_imp->set(a, n);
     }
 
-    void manager::swap(numeral & a, numeral & b) {
+    void manager::swap(numeral & a, numeral & b) noexcept {
         std::swap(a.m_value, b.m_value);
     }
 

src/math/realclosure/realclosure.h

@@ -164,7 +164,7 @@ namespace realclosure {
         void set(numeral & a, mpq const & n);
         void set(numeral & a, numeral const & n);
 
-        void swap(numeral & a, numeral & b);
+        void swap(numeral & a, numeral & b) noexcept;
 
         /**
            \brief Return a^{1/k}

src/muz/rel/dl_base.h

@@ -484,7 +484,7 @@ namespace datalog {
 
             virtual bool can_swap(const base_object & o) const { return false; }
 
-            virtual void swap(base_object & o) {
+            virtual void swap(base_object & o) noexcept {
                 std::swap(m_kind, o.m_kind);
 #if DL_LEAK_HUNTING
                 m_leak_guard = get_plugin().get_ast_manager().mk_fresh_sort(get_plugin().get_name().bare_str());
@@ -910,7 +910,7 @@ namespace datalog {
     public:
         table_signature() : m_functional_columns(0) {}
 
-        void swap(table_signature & s) {
+        void swap(table_signature & s) noexcept {
             signature_base::swap(s);
             std::swap(m_functional_columns, s.m_functional_columns);
         }

src/muz/rel/dl_finite_product_relation.cpp

@@ -1835,7 +1835,7 @@ namespace datalog {
         }
     }
 
-    void finite_product_relation::swap(relation_base & r0) {
+    void finite_product_relation::swap(relation_base & r0) noexcept {
         SASSERT(can_swap(r0));
         finite_product_relation & r = finite_product_relation_plugin::get(r0);
         SASSERT(get_signature()==r.get_signature());

src/muz/rel/dl_finite_product_relation.h

@@ -316,7 +316,7 @@ namespace datalog {
 
            Both relations must come from the same plugin and be of the same signature.
         */
-        void swap(relation_base & r) override;
+        void swap(relation_base & r) noexcept override;
 
         /**
            \brief Create a \c finite_product_relation object.

src/muz/rel/dl_vector_relation.h

@@ -59,7 +59,7 @@ namespace datalog {
             dealloc(m_elems);
         }
 
-        void swap(relation_base& other) override {
+        void swap(relation_base& other) noexcept override {
             vector_relation& o = dynamic_cast<vector_relation&>(other);
             if (&o == this) return;
             std::swap(o.m_eqs, m_eqs);

src/nlsat/nlsat_assignment.h

@@ -33,7 +33,7 @@ namespace nlsat {
     public:
         assignment(anum_manager & _m):m_values(_m) {}
         anum_manager & am() const { return m_values.m(); }
-        void swap(assignment & other) {
+        void swap(assignment & other) noexcept {
             m_values.swap(other.m_values);
             m_assigned.swap(other.m_assigned);
         }
@@ -67,7 +67,7 @@ namespace nlsat {
         anum_manager & m() const override { return am(); }
         bool contains(var x) const override { return is_assigned(x); }
         anum const & operator()(var x) const override { SASSERT(is_assigned(x)); return value(x); }
-        void swap(var x, var y) {
+        void swap(var x, var y) noexcept {
             SASSERT(x < m_values.size() && y < m_values.size());
             std::swap(m_assigned[x], m_assigned[y]);
             std::swap(m_values[x], m_values[y]);

src/nlsat/nlsat_scoped_literal_vector.h

@@ -67,7 +67,7 @@ namespace nlsat {
         void append(scoped_literal_vector const& ls) {
             append(ls.size(), ls.data());
         }
-        void swap(scoped_literal_vector& other) {
+        void swap(scoped_literal_vector& other) noexcept {
             SASSERT(&m_solver == &other.m_solver);
             m_lits.swap(other.m_lits);
         }

src/nlsat/nlsat_solver.cpp

@@ -48,7 +48,7 @@ namespace nlsat {
     typedef chashtable<root_atom*, root_atom::hash_proc, root_atom::eq_proc> root_atom_table;
 
     // for apply_permutation procedure
-    void swap(clause * & c1, clause * & c2) {
+    void swap(clause * & c1, clause * & c2) noexcept {
         std::swap(c1, c2);
     }
 

src/sat/sat_cutset.h

@@ -183,7 +183,7 @@ namespace sat {
         void reset(on_update_t& on_del) { shrink(on_del, 0); }
         cut const & operator[](unsigned idx) const { return m_cuts[idx]; }
         void shrink(on_update_t& on_del, unsigned j); 
-        void swap(cut_set& other) { 
+        void swap(cut_set& other) noexcept {
             std::swap(m_var, other.m_var);
             std::swap(m_size, other.m_size); 
             std::swap(m_max_size, other.m_max_size); 

src/sat/sat_model_converter.cpp

@@ -369,7 +369,7 @@ namespace sat {
         return result;
     }
 
-    void model_converter::swap(bool_var v, unsigned sz, literal_vector& clause) {
+    void model_converter::swap(bool_var v, unsigned sz, literal_vector& clause) noexcept {
         for (unsigned j = 0; j < sz; ++j) {
             if (v == clause[j].var()) {
                 std::swap(clause[0], clause[j]);

src/sat/sat_model_converter.h

@@ -91,7 +91,7 @@ namespace sat {
 
         bool legal_to_flip(bool_var v) const;
 
-        void swap(bool_var v, unsigned sz, literal_vector& clause);
+        void swap(bool_var v, unsigned sz, literal_vector& clause) noexcept;
 
         void add_elim_stack(entry & e);
 

src/sat/smt/pb_card.h

@@ -33,7 +33,7 @@ namespace pb {
         literal const* begin() const { return m_lits; }
         literal const* end() const { return static_cast<literal const*>(m_lits) + m_size; }
         void negate() override;
-        void swap(unsigned i, unsigned j) override { std::swap(m_lits[i], m_lits[j]); }
+        void swap(unsigned i, unsigned j) noexcept override { std::swap(m_lits[i], m_lits[j]); }
         literal_vector literals() const override { return literal_vector(m_size, m_lits); }
         bool is_watching(literal l) const override;
         literal get_lit(unsigned i) const override { return m_lits[i]; }

src/sat/smt/pb_constraint.h

@@ -102,7 +102,7 @@ namespace pb {
         
         virtual bool is_watching(literal l) const { UNREACHABLE(); return false; };
         virtual literal_vector literals() const { UNREACHABLE(); return literal_vector(); }
-        virtual void swap(unsigned i, unsigned j) { UNREACHABLE(); }
+        virtual void swap(unsigned i, unsigned j) noexcept { UNREACHABLE(); }
         virtual literal get_lit(unsigned i) const { UNREACHABLE(); return sat::null_literal; }
         virtual void set_lit(unsigned i, literal l) { UNREACHABLE(); }
         virtual void negate() { UNREACHABLE(); }

src/sat/smt/pb_pb.h

@@ -46,7 +46,7 @@ namespace pb {
         bool is_cardinality() const;
         void negate() override;
         void set_k(unsigned k) override { m_k = k; VERIFY(k < 4000000000); update_max_sum(); }
-        void swap(unsigned i, unsigned j) override { std::swap(m_wlits[i], m_wlits[j]); }
+        void swap(unsigned i, unsigned j) noexcept override { std::swap(m_wlits[i], m_wlits[j]); }
         literal_vector literals() const override { literal_vector lits; for (auto wl : *this) lits.push_back(wl.second); return lits; }
         bool is_watching(literal l) const override;
         literal get_lit(unsigned i) const override { return m_wlits[i].second; }

src/smt/old_interval.cpp

@@ -238,7 +238,7 @@ interval & interval::operator=(interval const & other) {
     return *this;
 }
 
-interval & interval::operator=(interval && other) {
+interval & interval::operator=(interval && other) noexcept {
     SASSERT(&m_manager == &other.m_manager);
     m_lower = std::move(other.m_lower);
     m_upper = std::move(other.m_upper);

src/smt/old_interval.h

@@ -92,7 +92,7 @@ public:
     rational const & get_lower_value() const { SASSERT(!minus_infinity()); return m_lower.to_rational(); }
     rational const & get_upper_value() const { SASSERT(!plus_infinity()); return m_upper.to_rational(); }
     old_interval & operator=(old_interval const & other);
-    old_interval & operator=(old_interval && other);
+    old_interval & operator=(old_interval && other) noexcept;
     old_interval & operator+=(old_interval const & other);
     old_interval & operator-=(old_interval const & other);
     old_interval & operator*=(old_interval const & other);

src/util/array.h

@@ -184,7 +184,7 @@ public:
     T const * data() const { return m_data; }
     T * data() { return m_data; }
 
-    void swap(array & other) {
+    void swap(array & other) noexcept {
         std::swap(m_data, other.m_data);
     }
 

src/util/basic_interval.h

@@ -52,8 +52,8 @@ public:
         interval const & get() const { return m_interval; }
         interval & get() { return m_interval; }
         void reset() { m().reset(m_interval); }
-        void swap(scoped_interval & a) { m().swap(m_interval, a.m_interval); }
-        void swap(interval & a) { m().swap(m_interval, a); }
+        void swap(scoped_interval & a) noexcept { m().swap(m_interval, a.m_interval); }
+        void swap(interval & a) noexcept { m().swap(m_interval, a); }
         bound const & lower() const { return m_interval.lower(); }
         bound const & upper() const { return m_interval.upper(); }
         bound & lower() { return m_interval.lower(); }
@@ -146,7 +146,7 @@ public:
         m().set(a.m_upper, n);
     }
 
-    void swap(interval & a, interval & b) {
+    void swap(interval & a, interval & b) noexcept {
         m().swap(a.m_lower, b.m_lower);
         m().swap(a.m_upper, b.m_upper);
     }

src/util/bit_vector.h

@@ -98,7 +98,7 @@ public:
         m_num_bits = 0;
     }
 
-    void swap(bit_vector & other) {
+    void swap(bit_vector & other) noexcept {
         std::swap(m_data, other.m_data);
         std::swap(m_num_bits, other.m_num_bits);
         std::swap(m_capacity, other.m_capacity);

src/util/chashtable.h

@@ -553,7 +553,7 @@ public:
     iterator begin() const { return iterator(m_table, m_table + m_slots); }
     iterator end() const { return iterator(); }
 
-    void swap(chashtable & other) {
+    void swap(chashtable & other) noexcept {
         std::swap(m_table,       other.m_table);
         std::swap(m_capacity,    other.m_capacity);
         std::swap(m_init_slots,  other.m_init_slots);

src/util/double_manager.h

@@ -76,7 +76,7 @@ public:
     static void set(double & a, unsigned val) { a = static_cast<double>(val); }
     static void set(double & a, int64_t val) { a = static_cast<double>(val); }
     static void set(double & a, uint64_t val) { a = static_cast<double>(val); }
-    static void swap(double & a, double & b) { std::swap(a, b); }
+    static void swap(double & a, double & b) noexcept { std::swap(a, b); }
     bool is_pos(double a) const { return a > m_zero_tolerance; }
     bool is_neg(double a) const { return a < m_zero_tolerance; }
     bool is_zero(double a) const { return  -m_zero_tolerance <= a && a <= m_zero_tolerance; }

src/util/f2n.h

@@ -45,7 +45,7 @@ public:
         m_manager.set(m_one, ebits, sbits, 1);
     }
 
-    f2n(f2n && other) : m_manager(other.m_manager), m_mode(other.m_mode), m_ebits(other.m_ebits), m_sbits(other.m_sbits),
+    f2n(f2n && other) noexcept : m_manager(other.m_manager), m_mode(other.m_mode), m_ebits(other.m_ebits), m_sbits(other.m_sbits),
         m_tmp1(std::move(other.m_tmp1)), m_one(std::move(other.m_one)) {}
 
     ~f2n() { 
@@ -86,7 +86,7 @@ public:
     void set(numeral & o, numeral const & x) { m().set(o, x); check(o); }
     void set(numeral & o, mpq const & x) { m().set(o, m_ebits, m_sbits, m_mode, x); check(o); }
     void reset(numeral & o) { m().reset(o, m_ebits, m_sbits); }
-    static void swap(numeral & x, numeral & y) { x.swap(y); }
+    static void swap(numeral & x, numeral & y) noexcept { x.swap(y); }
     
     void add(numeral const & x, numeral const & y, numeral & o) { m().add(m_mode, x, y, o); check(o); }
     void sub(numeral const & x, numeral const & y, numeral & o) { m().sub(m_mode, x, y, o); check(o); }

src/util/hashtable.h

@@ -283,7 +283,7 @@ public:
         delete_table();
     }
 
-    void swap(core_hashtable & source) {
+    void swap(core_hashtable & source) noexcept {
         std::swap(m_table,       source.m_table);
         std::swap(m_capacity,    source.m_capacity);
         std::swap(m_size,        source.m_size);

src/util/heap.h

@@ -259,7 +259,7 @@ public:
         return m_values.end(); 
     }
 
-    void swap(heap & other) {
+    void swap(heap & other) noexcept {
         if (this != &other) {
             CASSERT("heap", other.check_invariant());
             CASSERT("heap", check_invariant());

src/util/hwf.h

@@ -35,7 +35,7 @@ class hwf {
     }
 
 public:
-    void swap(hwf & other) { std::swap(value, other.value); }
+    void swap(hwf & other) noexcept { std::swap(value, other.value); }
 };
 
 

src/util/inf_eps_rational.h

@@ -38,7 +38,7 @@ class inf_eps_rational {
 
     struct eq_proc { bool operator()(inf_eps_rational const& r1, inf_eps_rational const& r2) const { return r1 == r2; } };
 
-    void swap(inf_eps_rational & n) { 
+    void swap(inf_eps_rational & n) noexcept {
         m_infty.swap(n.m_infty);
         m_r.swap(n.m_r);
     }

src/util/inf_int_rational.h

@@ -43,7 +43,7 @@ class inf_int_rational {
 
     struct eq_proc { bool operator()(inf_int_rational const& r1, inf_int_rational const& r2) const { return r1 == r2; } };
 
-    void swap(inf_int_rational & n) { 
+    void swap(inf_int_rational & n) noexcept {
         m_first.swap(n.m_first);
         std::swap(m_second, n.m_second);
     }

src/util/inf_rational.h

@@ -44,7 +44,7 @@ class inf_rational {
 
     struct eq_proc { bool operator()(inf_rational const& r1, inf_rational const& r2) const { return r1 == r2; } };
 
-    void swap(inf_rational & n) { 
+    void swap(inf_rational & n) noexcept {
         m_first.swap(n.m_first);
         m_second.swap(n.m_second);
     }

src/util/inf_s_integer.h

@@ -37,7 +37,7 @@ class inf_s_integer {
 
     struct eq_proc { bool operator()(inf_s_integer const& r1, inf_s_integer const& r2) const { return r1 == r2; } };
 
-    void swap(inf_s_integer & n) { 
+    void swap(inf_s_integer & n) noexcept {
         std::swap(m_first, n.m_first);
         std::swap(m_second, n.m_second);
     }

src/util/map.h

@@ -184,7 +184,7 @@ public:
 
     unsigned long long get_num_collision() const { return m_table.get_num_collision(); }
 
-    void swap(table2map & other) {
+    void swap(table2map & other) noexcept {
         m_table.swap(other.m_table);
     }
 

src/util/mpbq.h

@@ -40,10 +40,10 @@ public:
     mpbq(int v, unsigned k):m_num(v), m_k(k) {}
     mpz const & numerator() const { return m_num; }
     unsigned k() const { return m_k; }
-    void swap(mpbq & other) { m_num.swap(other.m_num); std::swap(m_k, other.m_k); }
+    void swap(mpbq & other) noexcept { m_num.swap(other.m_num); std::swap(m_k, other.m_k); }
 };
 
-inline void swap(mpbq & m1, mpbq & m2) { m1.swap(m2); }
+inline void swap(mpbq & m1, mpbq & m2) noexcept { m1.swap(m2); }
 
 typedef svector<mpbq> mpbq_vector;
 
@@ -72,7 +72,7 @@ public:
     mpbq_manager(unsynch_mpz_manager & m);
     ~mpbq_manager();
 
-    static void swap(mpbq & a, mpbq & b) { a.swap(b); }
+    static void swap(mpbq & a, mpbq & b) noexcept { a.swap(b); }
 
     void del(mpbq & a) { m_manager.del(a.m_num); }
     void reset(mpbq & a) { m_manager.reset(a.m_num); a.m_k = 0; }

src/util/mpf.cpp

@@ -41,7 +41,7 @@ mpf::mpf(unsigned _ebits, unsigned _sbits):
     set(ebits, sbits);
 }
 
-void mpf::swap(mpf & other) {
+void mpf::swap(mpf & other) noexcept {
     unsigned tmp = ebits;
     ebits = other.ebits;
     other.ebits = tmp;

src/util/mpf.h

@@ -52,7 +52,7 @@ public:
     mpf & operator=(mpf const & other) = delete;
     unsigned get_ebits() const { return ebits; }
     unsigned get_sbits() const { return sbits; }
-    void swap(mpf & other);
+    void swap(mpf & other) noexcept;
 };
 
 class mpf_manager {
@@ -87,7 +87,7 @@ public:
     void neg(mpf & o);
     void neg(mpf const & x, mpf & o);
     
-    void swap(mpf& a, mpf& b) { a.swap(b); }
+    void swap(mpf& a, mpf& b) noexcept { a.swap(b); }
 
     bool is_zero(mpf const & x);
     bool is_neg(mpf const & x);

src/util/mpff.h

@@ -44,14 +44,14 @@ public:
         m_exponent(0) {
     }
     
-    void swap(mpff & other) { 
+    void swap(mpff & other) noexcept {
         unsigned sign    = m_sign;    m_sign    = other.m_sign;    other.m_sign = sign;
         unsigned sig_idx = m_sig_idx; m_sig_idx = other.m_sig_idx; other.m_sig_idx = sig_idx;
         std::swap(m_exponent, other.m_exponent); 
     }
 };
 
-inline void swap(mpff & m1, mpff & m2) { m1.swap(m2); }
+inline void swap(mpff & m1, mpff & m2) noexcept { m1.swap(m2); }
 
 class mpz;
 class mpq;
@@ -316,7 +316,7 @@ public:
     */
     static void abs(mpff & a) { a.m_sign = 0; }
 
-    static void swap(mpff & a, mpff & b) { a.swap(b); }
+    static void swap(mpff & a, mpff & b) noexcept { a.swap(b); }
 
     /**
        \brief c <- a + b

src/util/mpfx.h

@@ -38,13 +38,13 @@ public:
         m_sig_idx(0) {
     }
     
-    void swap(mpfx & other) { 
+    void swap(mpfx & other) noexcept {
         unsigned sign    = m_sign;    m_sign    = other.m_sign;    other.m_sign = sign;
         unsigned sig_idx = m_sig_idx; m_sig_idx = other.m_sig_idx; other.m_sig_idx = sig_idx;
     }
 };
 
-inline void swap(mpfx & m1, mpfx & m2) { m1.swap(m2); }
+inline void swap(mpfx & m1, mpfx & m2) noexcept { m1.swap(m2); }
 
 class mpz;
 class mpq;
@@ -228,7 +228,7 @@ public:
     */
     static void abs(mpfx & a) { a.m_sign = 0; }
 
-    static void swap(mpfx & a, mpfx & b) { a.swap(b); }
+    static void swap(mpfx & a, mpfx & b) noexcept { a.swap(b); }
 
     /**
        \brief c <- a + b

src/util/mpq.h

@@ -761,9 +761,9 @@ public:
         return temp;
     }
 
-    void swap(mpz & a, mpz & b) { mpz_manager<SYNCH>::swap(a, b); }
+    void swap(mpz & a, mpz & b) noexcept { mpz_manager<SYNCH>::swap(a, b); }
 
-    void swap(mpq & a, mpq & b) {
+    void swap(mpq & a, mpq & b) noexcept {
         swap(a.m_num, b.m_num);
         swap(a.m_den, b.m_den);
     }

src/util/mpq_inf.h

@@ -52,7 +52,7 @@ public:
         m.del(a.second);
     }
 
-    void swap(mpq_inf & a, mpq_inf & b) {
+    void swap(mpq_inf & a, mpq_inf & b) noexcept {
         m.swap(a.first, b.first);
         m.swap(a.second, b.second);
     }

src/util/mpz.h

@@ -110,7 +110,7 @@ public:
         return *this;
     }
 
-    void swap(mpz & other) { 
+    void swap(mpz & other) noexcept {
         std::swap(m_val, other.m_val);
         std::swap(m_ptr, other.m_ptr);
         unsigned o = m_owner; m_owner = other.m_owner; other.m_owner = o;
@@ -131,7 +131,7 @@ public:
 class mpz_stack : public mpz {};
 #endif
 
-inline void swap(mpz & m1, mpz & m2) { m1.swap(m2); }
+inline void swap(mpz & m1, mpz & m2) noexcept { m1.swap(m2); }
 
 template<bool SYNCH = true>
 class mpz_manager {
@@ -573,7 +573,7 @@ public:
     // deallocates any memory.
     void reset(mpz & a);
 
-    void swap(mpz & a, mpz & b) {
+    void swap(mpz & a, mpz & b) noexcept {
         std::swap(a.m_val, b.m_val);
         std::swap(a.m_ptr, b.m_ptr);
         auto o = a.m_owner; a.m_owner = b.m_owner; b.m_owner = o;

src/util/mpzzp.h

@@ -183,7 +183,7 @@ public:
         }
     }
     
-    void swap(mpz & a, mpz & b) {
+    void swap(mpz & a, mpz & b) noexcept {
         SASSERT(is_p_normalized(a) && is_p_normalized(b));
         m().swap(a, b);
     }

src/util/numeral_buffer.h

@@ -81,7 +81,7 @@ public:
         m_buffer.reserve(sz);
     }
 
-    void swap(svector<Numeral> & other) {
+    void swap(svector<Numeral> & other) noexcept {
         m_buffer.swap(other);
     }
 

src/util/obj_hashtable.h

@@ -209,7 +209,7 @@ public:
         }
     }
 
-    void swap(obj_map & other) {
+    void swap(obj_map & other) noexcept {
         m_table.swap(other.m_table);
     }
 };

src/util/obj_ref.h

@@ -93,7 +93,7 @@ public:
         return *this;
     }
 
-    obj_ref & operator=(obj_ref && n) {
+    obj_ref & operator=(obj_ref && n) noexcept {
         SASSERT(&m_manager == &n.m_manager);
         std::swap(m_obj, n.m_obj);
         n.reset();
@@ -105,7 +105,7 @@ public:
         m_obj = nullptr;
     }
 
-    void swap(obj_ref & n) {
+    void swap(obj_ref & n) noexcept {
         std::swap(m_obj, n.m_obj);
     }
 

src/util/obj_ref_hashtable.h

@@ -104,7 +104,7 @@ public:
 
     unsigned long long get_num_collision() const { return m_table.get_num_collision(); }
 
-    void swap(obj_ref_map & other) {
+    void swap(obj_ref_map & other) noexcept {
         m_table.swap(other.m_table);
     }
 

src/util/optional.h

@@ -94,7 +94,7 @@ public:
         return * this;
     }
 
-    optional & operator=(optional && val) {
+    optional & operator=(optional && val) noexcept {
         std::swap(m_obj, val.m_obj);
         return *this;
     }

src/util/permutation.cpp

@@ -31,7 +31,7 @@ void permutation::reset(unsigned size) {
     }
 }
 
-void permutation::swap(unsigned i, unsigned j) {
+void permutation::swap(unsigned i, unsigned j) noexcept {
     unsigned i_prime = m_p[i];
     unsigned j_prime = m_p[j];
     std::swap(m_p[i], m_p[j]);

src/util/permutation.h

@@ -31,7 +31,7 @@ public:
     unsigned operator()(unsigned i) const { return m_p[i]; }
     unsigned inv(unsigned i_prime) const { return m_inv_p[i_prime]; }
 
-    void swap(unsigned i, unsigned j);
+    void swap(unsigned i, unsigned j) noexcept;
     void move_after(unsigned i, unsigned j);
     
     void display(std::ostream & out) const;

src/util/rational.h

@@ -86,7 +86,7 @@ public:
 
     struct eq_proc { bool operator()(rational const& r1, rational const& r2) const { return r1 == r2; } };
     
-    void swap(rational & n) { m().swap(m_val, n.m_val); }
+    void swap(rational & n) noexcept { m().swap(m_val, n.m_val); }
     
     std::string to_string() const { return m().to_string(m_val); }
 
@@ -671,6 +671,6 @@ inline rational gcd(rational const & r1, rational const & r2, rational & a, rati
   return result;
 }
 
-inline void swap(rational& r1, rational& r2) {
+inline void swap(rational& r1, rational& r2) noexcept {
     r1.swap(r2);
 }

src/util/ref.h

@@ -97,7 +97,7 @@ public:
         return *this;
     }
 
-    ref & operator=(ref &&r) {
+    ref & operator=(ref &&r) noexcept {
         if (this != &r) {
            dec_ref ();
            m_ptr = r.detach ();
@@ -123,7 +123,7 @@ public:
     friend bool operator!=(const ref & r1, const ref & r2) {
         return r1.m_ptr != r2.m_ptr;
     }
-    friend void swap (ref &r1, ref &r2) {
+    friend void swap (ref &r1, ref &r2) noexcept {
         T* tmp = r1.m_ptr;
         r1.m_ptr = r2.m_ptr;
         r2.m_ptr = tmp;

src/util/ref_pair_vector.h

@@ -143,7 +143,7 @@ public:
             push_back(other[i]);
     }
 
-    void swap(unsigned idx1, unsigned idx2) {
+    void swap(unsigned idx1, unsigned idx2) noexcept {
         std::swap(m_nodes[idx1], m_nodes[idx2]);
     }
 
@@ -179,7 +179,7 @@ public:
         this->append(other);
     }
 
-    ref_pair_vector(ref_pair_vector && other) : super(std::move(other)) {}
+    ref_pair_vector(ref_pair_vector && other) noexcept : super(std::move(other)) {}
 
     ref_pair_vector(TManager & m, unsigned sz, elem_t const * data):
         super(ref_manager_wrapper<T, TManager>(m)) {
@@ -194,7 +194,7 @@ public:
         return get_manager();
     }
 
-    void swap(ref_pair_vector & other) {
+    void swap(ref_pair_vector & other) noexcept {
         SASSERT(&(this->m_manager) == &(other.m_manager));
         this->m_nodes.swap(other.m_nodes);
     }

src/util/ref_vector.h

@@ -197,14 +197,14 @@ public:
             push_back(data[i]);
     }
 
-    void operator=(ref_vector_core && other) {
+    void operator=(ref_vector_core && other) noexcept {
         if (this != &other) {
             reset();
             m_nodes = std::move(other.m_nodes);
         }
     }
 
-    void swap(unsigned idx1, unsigned idx2) {
+    void swap(unsigned idx1, unsigned idx2) noexcept {
         std::swap(m_nodes[idx1], m_nodes[idx2]);
     }
 
@@ -262,7 +262,7 @@ public:
         return get_manager();
     }
 
-    void swap(ref_vector & other) {
+    void swap(ref_vector & other) noexcept {
         SASSERT(&(this->m_manager) == &(other.m_manager));
         this->m_nodes.swap(other.m_nodes);
     }

src/util/s_integer.h

@@ -34,7 +34,7 @@ public:
     struct hash_proc {  unsigned operator()(s_integer const& r) const { return r.hash(); }  };
     struct eq_proc { bool operator()(s_integer const& r1, s_integer const& r2) const { return r1 == r2; } };
 
-    void swap(s_integer & n) { 
+    void swap(s_integer & n) noexcept {
         std::swap(m_val, n.m_val);
     }
 

src/util/scoped_numeral.h

@@ -60,11 +60,11 @@ public:
         m().reset(m_num);
     }
 
-    void swap(_scoped_numeral & n) {
+    void swap(_scoped_numeral & n) noexcept {
         m().swap(m_num, n.m_num);
     }
 
-    void swap(numeral & n) {
+    void swap(numeral & n) noexcept {
         m().swap(m_num, n);
     }
 

src/util/scoped_ptr_vector.h

@@ -34,7 +34,7 @@ public:
     scoped_ptr_vector(scoped_ptr_vector&& other) noexcept {
         m_vector.swap(other.m_vector);
     }
-    scoped_ptr_vector& operator=(scoped_ptr_vector&& other) {
+    scoped_ptr_vector& operator=(scoped_ptr_vector&& other) noexcept {
         if (this == &other)
             return *this;
         reset();
@@ -55,7 +55,7 @@ public:
         dealloc(m_vector[idx]); 
         m_vector[idx] = ptr; 
     }
-    void swap(unsigned i, unsigned j) { std::swap(m_vector[i], m_vector[j]); }
+    void swap(unsigned i, unsigned j) noexcept { std::swap(m_vector[i], m_vector[j]); }
     unsigned size() const { return m_vector.size(); }
     bool empty() const { return m_vector.empty(); }
     void resize(unsigned sz) { 

src/util/tbv.h

@@ -135,7 +135,7 @@ class tbv_ref {
 public:
     tbv_ref(tbv_manager& mgr) : mgr(mgr), d(nullptr) {}
     tbv_ref(tbv_manager& mgr, tbv* d) : mgr(mgr), d(d) {}
-    tbv_ref(tbv_ref&& d) : mgr(d.mgr), d(d.detach()) {}
+    tbv_ref(tbv_ref&& d) noexcept : mgr(d.mgr), d(d.detach()) {}
     ~tbv_ref() {
         if (d) mgr.deallocate(d);
     }

src/util/uint_set.h

@@ -28,7 +28,7 @@ public:
     
     typedef unsigned data;
 
-    void swap(uint_set & other) {
+    void swap(uint_set & other) noexcept {
         unsigned_vector::swap(other);
     }
 

src/util/util.h

@@ -265,7 +265,7 @@ public:
         return *this;
     }
 
-    scoped_ptr& operator=(scoped_ptr&& other) {
+    scoped_ptr& operator=(scoped_ptr&& other) noexcept {
         *this = other.detach();
         return *this;
     };
@@ -276,7 +276,7 @@ public:
         return tmp;
     }
 
-    void swap(scoped_ptr & p) {
+    void swap(scoped_ptr & p) noexcept {
         std::swap(m_ptr, p.m_ptr);
     }
 };

src/util/vector.h

@@ -330,7 +330,7 @@ public:
         return *this;
     }
 
-    vector & operator=(vector && source) {
+    vector & operator=(vector && source) noexcept {
         if (this == &source) {
             return *this;
         }