Make constant_exprt variant of operator== member functions

This provides access to methods that may eventually become private.

Author: tautschnig

src/util/std_expr.cpp

@@ -39,14 +39,14 @@ bool operator!=(const exprt &lhs, bool rhs)
   return !lhs.is_constant() || to_constant_expr(lhs) != rhs;
 }
 
-bool operator==(const constant_exprt &lhs, bool rhs)
+bool constant_exprt::operator==(bool rhs) const
 {
-  return lhs.is_boolean() && (lhs.get_value() != ID_false) == rhs;
+  return is_boolean() && (get_value() != ID_false) == rhs;
 }
 
-bool operator!=(const constant_exprt &lhs, bool rhs)
+bool constant_exprt::operator!=(bool rhs) const
 {
-  return !lhs.is_boolean() || (lhs.get_value() != ID_false) != rhs;
+  return !is_boolean() || (get_value() != ID_false) != rhs;
 }
 
 bool operator==(const exprt &lhs, int rhs)
@@ -65,94 +65,94 @@ bool operator!=(const exprt &lhs, int rhs)
     return true;
 }
 
-bool operator==(const constant_exprt &lhs, int rhs)
+bool constant_exprt::operator==(int rhs) const
 {
   if(rhs == 0)
   {
-    const irep_idt &type_id = lhs.type().id();
+    const irep_idt &type_id = type().id();
 
     if(type_id == ID_integer)
     {
-      return integer_typet{}.zero_expr() == lhs;
+      return integer_typet{}.zero_expr() == *this;
     }
     else if(type_id == ID_natural)
     {
-      return natural_typet{}.zero_expr() == lhs;
+      return natural_typet{}.zero_expr() == *this;
     }
     else if(type_id == ID_real)
     {
-      return real_typet{}.zero_expr() == lhs;
+      return real_typet{}.zero_expr() == *this;
     }
     else if(type_id == ID_rational)
     {
       rationalt rat_value;
-      if(to_rational(lhs, rat_value))
+      if(to_rational(*this, rat_value))
         CHECK_RETURN(false);
       return rat_value.is_zero();
     }
     else if(
       type_id == ID_unsignedbv || type_id == ID_signedbv ||
       type_id == ID_c_bool || type_id == ID_c_bit_field)
     {
-      return lhs.value_is_zero_string();
+      return value_is_zero_string();
     }
     else if(type_id == ID_fixedbv)
     {
-      return fixedbvt(lhs).is_zero();
+      return fixedbvt(*this).is_zero();
     }
     else if(type_id == ID_floatbv)
     {
-      return ieee_float_valuet(lhs).is_zero();
+      return ieee_float_valuet(*this).is_zero();
     }
     else if(type_id == ID_pointer)
     {
-      return lhs == nullptr;
+      return *this == nullptr;
     }
     else
       return false;
   }
   else if(rhs == 1)
   {
-    const irep_idt &type_id = lhs.type().id();
+    const irep_idt &type_id = type().id();
 
     if(type_id == ID_integer)
     {
-      return integer_typet{}.one_expr() == lhs;
+      return integer_typet{}.one_expr() == *this;
     }
     else if(type_id == ID_natural)
     {
-      return natural_typet{}.one_expr() == lhs;
+      return natural_typet{}.one_expr() == *this;
     }
     else if(type_id == ID_real)
     {
-      return real_typet{}.one_expr() == lhs;
+      return real_typet{}.one_expr() == *this;
     }
     else if(type_id == ID_rational)
     {
       rationalt rat_value;
-      if(to_rational(lhs, rat_value))
+      if(to_rational(*this, rat_value))
         CHECK_RETURN(false);
       return rat_value.is_one();
     }
     else if(
       type_id == ID_unsignedbv || type_id == ID_signedbv ||
       type_id == ID_c_bool || type_id == ID_c_bit_field)
     {
-      const auto width = to_bitvector_type(lhs.type()).get_width();
+      const auto width = to_bitvector_type(type()).get_width();
       mp_integer int_value =
-        bvrep2integer(id2string(lhs.get_value()), width, false);
+        bvrep2integer(id2string(get_value()), width, false);
       return int_value == 1;
     }
     else if(type_id == ID_fixedbv)
     {
-      fixedbv_spect spec{to_fixedbv_type(lhs.type())};
+      fixedbv_spect spec{to_fixedbv_type(type())};
       fixedbvt one{spec};
       one.from_integer(1);
-      return one == fixedbvt{lhs};
+      return one == fixedbvt{*this};
     }
     else if(type_id == ID_floatbv)
     {
-      return ieee_float_valuet(lhs) == 1;
+      return ieee_float_valuet(*this) == 1;
     }
     else
       return false;
@@ -161,10 +161,10 @@ bool operator==(const constant_exprt &lhs, int rhs)
     PRECONDITION(false);
 }
 
-bool operator!=(const constant_exprt &lhs, int rhs) const
+bool constant_exprt::operator!=(int rhs) const
 {
   PRECONDITION(rhs == 0 || rhs == 1);
-  return !(lhs == rhs);
+  return !(*this == rhs);
 }
 
 bool constant_exprt::is_null_pointer() const
@@ -195,16 +195,16 @@ bool operator!=(const exprt &lhs, std::nullptr_t rhs)
   return !lhs.is_constant() || !to_constant_expr(lhs).is_null_pointer();
 }
 
-bool operator==(const constant_exprt &lhs, std::nullptr_t rhs)
+bool constant_exprt::operator==(std::nullptr_t rhs) const
 {
   (void)rhs; // unused parameter
-  return lhs.is_null_pointer();
+  return is_null_pointer();
 }
 
-bool operator!=(const constant_exprt &lhs, std::nullptr_t rhs) const
+bool constant_exprt::operator!=(std::nullptr_t rhs) const
 {
   (void)rhs; // unused parameter
-  return !lhs.is_null_pointer();
+  return !is_null_pointer();
 }
 
 void constant_exprt::check(const exprt &expr, const validation_modet vm)

src/util/std_expr.h

@@ -3144,6 +3144,21 @@ class constant_exprt : public nullary_exprt
   /// false in all other cases.
   bool is_null_pointer() const;
 
+  using irept::operator==;
+  using irept::operator!=;
+  /// \copydoc operator==(const exprt &, bool)
+  bool operator==(bool rhs) const;
+  /// \copydoc operator!=(const exprt &, bool)
+  bool operator!=(bool rhs) const;
+  /// \copydoc operator==(const exprt &, int)
+  bool operator==(int rhs) const;
+  /// \copydoc operator!=(const exprt &, int)
+  bool operator!=(int rhs) const;
+  /// \copydoc operator==(const exprt &, std::nullptr_t)
+  bool operator==(std::nullptr_t) const;
+  /// \copydoc operator!=(const exprt &, std::nullptr_t)
+  bool operator!=(std::nullptr_t) const;
+
   static void check(
     const exprt &expr,
     const validation_modet vm = validation_modet::INVARIANT);
@@ -3192,14 +3207,10 @@ inline constant_exprt &to_constant_expr(exprt &expr)
 /// Return whether the expression \p lhs is a constant of Boolean type that is
 /// representing the Boolean value \p rhs.
 bool operator==(const exprt &lhs, bool rhs);
-/// \copydoc operator==(const exprt &, bool)
-bool operator==(const constant_exprt &lhs, bool rhs);
 
 /// Return whether the expression \p lhs is not a constant of Boolean type or is
 /// not representing the Boolean value \p rhs.
 bool operator!=(const exprt &lhs, bool rhs);
-/// \copydoc operator!=(const exprt &, bool)
-bool operator!=(const constant_exprt &lhs, bool rhs);
 
 /// Return whether the expression \p lhs is a constant representing the numeric
 /// value \p rhs; only values 0 and 1 are supported for \p rhs.
@@ -3213,24 +3224,16 @@ bool operator!=(const constant_exprt &lhs, bool rhs);
 /// ID_fixedbv, ID_floatbv.<br>
 /// For all other types, return false.
 bool operator==(const exprt &lhs, int rhs);
-/// \copydoc operator==(const exprt &, int)
-bool operator==(const constant_exprt &lhs, int rhs);
 
 /// Returns the negation of \ref operator==(const exprt &, int).
 bool operator!=(const exprt &lhs, int rhs);
-/// \copydoc operator!=(const exprt &, int)
-bool operator!=(const constant_exprt &lhs, int rhs);
 
 /// Return whether the expression \p lhs is a constant representing the NULL
 /// pointer.
 bool operator==(const exprt &lhs, std::nullptr_t);
-/// \copydoc operator==(const exprt &, std::nullptr_t)
-bool operator==(const constant_exprt &lhs, std::nullptr_t);
 
 /// Returns the negation of \ref operator==(const exprt &, std::nullptr_t).
 bool operator!=(const exprt &lhs, std::nullptr_t);
-/// \copydoc operator!=(const exprt &, std::nullptr_t)
-bool operator!=(const constant_exprt &lhs, std::nullptr_t);
 
 /// \brief The Boolean constant true
 class true_exprt:public constant_exprt