Use operator==(exprt, int) instead of is_one

Avoids use the newly deprecated exprt method.

Author: tautschnig

src/analyses/variable-sensitivity/interval_abstract_value.cpp

@@ -242,9 +242,10 @@ bool new_interval_is_top(const constant_interval_exprt &e)
   if(e.get_lower() == false && e.get_upper() == true)
     return true;
   if(
-    e.type().id() == ID_c_bool && e.get_lower().is_zero() &&
-    e.get_upper().is_one())
+    e.type().id() == ID_c_bool && e.get_lower().is_zero() && e.get_upper() == 1)
+  {
     return true;
+  }
 
   return false;
 }

src/analyses/variable-sensitivity/value_set_abstract_object.cpp

@@ -459,7 +459,7 @@ static bool is_set_extreme(const typet &type, const abstract_object_sett &set)
       },
       [](const abstract_value_objectt &value) {
         auto c = value.to_constant();
-        return c.is_one() || (c.id() == ID_max_value);
+        return c == 1 || (c.id() == ID_max_value);
       });
   }
 

src/ansi-c/goto-conversion/builtin_functions.cpp

@@ -618,7 +618,7 @@ static exprt make_va_list(const exprt &expr, const namespacet &ns)
   }
 
   while(result.type().id() == ID_array &&
-        to_array_type(result.type()).size().is_one())
+        to_array_type(result.type()).size() == 1)
   {
     result = index_exprt{result, from_integer(0, c_index_type())};
   }

src/ansi-c/parser.y

@@ -1606,8 +1606,10 @@ pragma_packed:
         {
           init($$);
           if(!PARSER.pragma_pack.empty() &&
-             PARSER.pragma_pack.back().is_one())
+             PARSER.pragma_pack.back() == 1)
+          {
             set($$, ID_packed);
+          }
         }
         ;
 

src/util/interval.cpp

@@ -689,7 +689,7 @@ exprt constant_interval_exprt::generate_division_expression(
 
   PRECONDITION(!is_zero(rhs));
 
-  if(rhs.is_one())
+  if(rhs == 1)
   {
     return lhs;
   }
@@ -744,7 +744,7 @@ exprt constant_interval_exprt::generate_modulo_expression(
 
   PRECONDITION(!is_zero(rhs));
 
-  if(rhs.is_one())
+  if(rhs == 1)
   {
     return lhs;
   }

src/util/simplify_expr.cpp

@@ -2556,7 +2556,7 @@ simplify_exprt::simplify_overflow_binary(const binary_overflow_exprt &expr)
   // One is neutral element for multiplication
   if(
     can_cast_expr<mult_overflow_exprt>(expr) &&
-    (expr.op0().is_one() || expr.op1().is_one()))
+    (expr.op0() == 1 || expr.op1() == 1))
   {
     return false_exprt{};
   }
@@ -2751,10 +2751,10 @@ simplify_exprt::simplify_overflow_result(const overflow_result_exprt &expr)
     // One is neutral element for multiplication
     if(
       expr.id() == ID_overflow_result_mult &&
-      (expr.op0().is_one() || expr.op1().is_one()))
+      (expr.op0() == 1 || expr.op1() == 1))
     {
       return struct_exprt{
-        {expr.op0().is_one() ? expr.op1() : expr.op0(), false_exprt{}},
+        {expr.op0() == 1 ? expr.op1() : expr.op0(), false_exprt{}},
         expr.type()};
     }
 

src/util/simplify_expr_floatbv.cpp

@@ -347,8 +347,9 @@ simplify_exprt::simplify_floatbv_op(const ieee_float_op_exprt &expr)
   }
 
   // division by one? Exact for all rounding modes.
-  if(expr.id()==ID_floatbv_div &&
-     op1.is_constant() && op1.is_one())
+  if(
+    expr.id() == ID_floatbv_div && op1.is_constant() &&
+    ieee_float_valuet{to_constant_expr(op1)} == 1)
   {
     return op0;
   }

src/util/simplify_expr_int.cpp

@@ -253,7 +253,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_mult(const mult_exprt &expr)
   else
   {
     // if the constant is a one and there are other factors
-    if(constant_found && constant->is_one())
+    if(constant_found && *constant == 1)
     {
       // just delete it
       new_operands.erase(constant);
@@ -346,8 +346,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_div(const div_exprt &expr)
   else if(expr_type.id()==ID_fixedbv)
   {
     // division by one?
-    if(expr.op1().is_constant() &&
-       expr.op1().is_one())
+    if(expr.op1().is_constant() && expr.op1() == 1)
     {
       return expr.op0();
     }
@@ -678,7 +677,7 @@ simplify_exprt::simplify_bitwise(const multi_ary_exprt &expr)
       if(op.id() == ID_typecast && to_typecast_expr(op).op().is_boolean())
       {
       }
-      else if(op.is_zero() || op.is_one())
+      else if(op.is_zero() || op == 1)
       {
       }
       else
@@ -707,7 +706,7 @@ simplify_exprt::simplify_bitwise(const multi_ary_exprt &expr)
           *it = to_typecast_expr(*it).op();
         else if(it->is_zero())
           *it=false_exprt();
-        else if(it->is_one())
+        else if(*it == 1)
           *it=true_exprt();
       }