use typecast_exprt() instead of .make_typecast

.make_typecast() isn't type safe; use the constructor for the
resulting expression instead.

Author: Daniel Kroening

src/ansi-c/c_typecast.cpp

@@ -735,16 +735,15 @@ void c_typecastt::do_typecast(exprt &expr, const typet &dest_type)
 
     if(dest_type.get(ID_C_c_type)==ID_bool)
     {
-      expr=is_not_zero(expr, ns);
-      expr.make_typecast(dest_type);
+      expr = typecast_exprt(is_not_zero(expr, ns), dest_type);
     }
     else if(dest_type.id()==ID_bool)
     {
       expr=is_not_zero(expr, ns);
     }
     else
     {
-      expr.make_typecast(dest_type);
+      expr = typecast_exprt(expr, dest_type);
     }
   }
 }

src/ansi-c/c_typecheck_code.cpp

@@ -667,7 +667,7 @@ void c_typecheck_baset::typecheck_return(codet &code)
         warning() << to_string(code.op0().type());
         warning() << eom;
 
-        code.op0().make_typecast(return_type);
+        code.op0() = typecast_exprt(code.op0(), return_type);
       }
     }
     else

src/ansi-c/c_typecheck_expr.cpp

@@ -420,7 +420,7 @@ void c_typecheck_baset::typecheck_expr_main(exprt &expr)
     // that we are using "bool" for boolean operators instead
     // of "int". We convert for this reason.
     if(expr.op0().type().id() == ID_bool)
-      expr.op0().make_typecast(signed_int_type());
+      expr.op0() = typecast_exprt(expr.op0(), signed_int_type());
 
     irept::subt &generic_associations=
       expr.add(ID_generic_associations).get_sub();
@@ -1104,7 +1104,7 @@ void c_typecheck_baset::typecheck_expr_typecast(exprt &expr)
     // that we are using "bool" for boolean operators instead
     // of "int". We convert for this reason.
     if(op.type().id() == ID_bool)
-      op.make_typecast(signed_int_type());
+      op = typecast_exprt(op, signed_int_type());
 
     // we need to find a member with the right type
     for(const auto &c : to_union_type(expr_type).components())
@@ -1409,19 +1409,19 @@ void c_typecheck_baset::typecheck_expr_rel(
     // pointer and integer
     if(type0.id()==ID_pointer && is_number(type1))
     {
-      op1.make_typecast(type0);
+      op1 = typecast_exprt(op1, type0);
       return;
     }
 
     if(type1.id()==ID_pointer && is_number(type0))
     {
-      op0.make_typecast(type1);
+      op0 = typecast_exprt(op0, type1);
       return;
     }
 
     if(type0.id()==ID_pointer && type1.id()==ID_pointer)
     {
-      op1.make_typecast(type0);
+      op1 = typecast_exprt(op1, type0);
       return;
     }
   }
@@ -1890,7 +1890,7 @@ void c_typecheck_baset::typecheck_expr_side_effect(side_effect_exprt &expr)
     {
       // promote to underlying type
       typet underlying_type = to_c_bit_field_type(type0).subtype();
-      expr.op0().make_typecast(underlying_type);
+      expr.op0() = typecast_exprt(expr.op0(), underlying_type);
       expr.type()=underlying_type;
     }
     else if(is_numeric_type(type0))
@@ -3326,7 +3326,7 @@ void c_typecheck_baset::typecheck_side_effect_assignment(
   // Add a cast to the underlying type for bit fields.
   // In particular, sizeof(s.f=1) works for bit fields.
   if(op0.type().id()==ID_c_bit_field)
-    op0.make_typecast(op0.type().subtype());
+    op0 = typecast_exprt(op0, op0.type().subtype());
 
   const typet o_type0=op0.type();
   const typet o_type1=op1.type();

src/ansi-c/c_typecheck_type.cpp

@@ -1020,7 +1020,7 @@ void c_typecheck_baset::typecheck_compound_body(
       exprt &assertion=it->op0();
       typecheck_expr(assertion);
       typecheck_expr(it->op1());
-      assertion.make_typecast(bool_typet());
+      assertion = typecast_exprt(assertion, bool_typet());
       make_constant(assertion);
 
       if(assertion.is_false())

src/cpp/cpp_typecheck_compound_type.cpp

@@ -1703,5 +1703,5 @@ void cpp_typecheckt::make_ptr_typecast(
     subtype_typecast(src_struct, dest_struct) ||
     subtype_typecast(dest_struct, src_struct));
 
-  expr.make_typecast(dest_type);
+  expr = typecast_exprt(expr, dest_type);
 }

src/linking/linking.cpp

@@ -1072,7 +1072,7 @@ void linkingt::duplicate_object_symbol(
   {
     // the type has been updated, now make sure that the initialising assignment
     // will have matching types
-    old_symbol.value.make_typecast(old_symbol.type);
+    old_symbol.value = typecast_exprt(old_symbol.value, old_symbol.type);
   }
 }
 

src/solvers/lowering/popcount.cpp

@@ -30,10 +30,12 @@ exprt lower_popcount(const popcount_exprt &expr, const namespacet &ns)
   CHECK_RETURN(x_width.has_value() && *x_width >= 1);
   const std::size_t bits = address_bits(*x_width);
   const std::size_t new_width = numeric_cast_v<std::size_t>(power(2, bits));
+
   const bool need_typecast =
     new_width > *x_width || x.type().id() != ID_unsignedbv;
+
   if(need_typecast)
-    x.make_typecast(unsignedbv_typet(new_width));
+    x = typecast_exprt(x, unsignedbv_typet(new_width));
 
   // repeatedly compute x = (x & bitmask) + ((x >> shift) & bitmask)
   for(std::size_t shift = 1; shift < new_width; shift <<= 1)
@@ -54,7 +56,5 @@ exprt lower_popcount(const popcount_exprt &expr, const namespacet &ns)
   }
 
   // the result is restricted to the result type
-  x.make_typecast(expr.type());
-
-  return x;
+  return typecast_exprt(x, expr.type());
 }

src/util/simplify_expr.cpp

@@ -364,7 +364,7 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
 
           Forall_operands(it, result)
           {
-            it->make_typecast(expr.type());
+            *it = typecast_exprt(*it, expr.type());
             simplify_typecast(*it); // recursive call
           }
 
@@ -397,11 +397,11 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
       {
         if(op.type().id()==ID_pointer)
         {
-          op.make_typecast(size_t_type);
+          op = typecast_exprt(op, size_t_type);
         }
         else
         {
-          op.make_typecast(size_t_type);
+          op = typecast_exprt(op, size_t_type);
           if(*step > 1)
             op = mult_exprt(from_integer(*step, size_t_type), op);
         }

src/util/simplify_expr_array.cpp

@@ -168,8 +168,7 @@ bool simplify_exprt::simplify_index(exprt &expr)
     // These are index/value pairs, alternating.
     for(size_t i=0; i<array.operands().size()/2; i++)
     {
-      exprt tmp_index=array.operands()[i*2];
-      tmp_index.make_typecast(index.type());
+      exprt tmp_index = typecast_exprt(array.operands()[i * 2], index.type());
       simplify(tmp_index);
       if(tmp_index==index)
       {

src/util/simplify_expr_int.cpp

@@ -703,7 +703,7 @@ bool simplify_exprt::simplify_bitwise(exprt &expr)
       new_expr.type()=bool_typet();
       simplify_node(new_expr);
 
-      new_expr.make_typecast(expr.type());
+      new_expr = typecast_exprt(new_expr, expr.type());
       simplify_node(new_expr);
 
       expr.swap(new_expr);

src/util/simplify_expr_pointer.cpp

@@ -270,8 +270,7 @@ bool simplify_exprt::simplify_pointer_offset(exprt &expr)
       if(ptr.op0().is_constant())
       {
         // (T *)0x1234 -> 0x1234
-        exprt tmp=ptr.op0();
-        tmp.make_typecast(expr.type());
+        exprt tmp = typecast_exprt(ptr.op0(), expr.type());
         simplify_node(tmp);
         expr.swap(tmp);
         return false;
@@ -321,7 +320,7 @@ bool simplify_exprt::simplify_pointer_offset(exprt &expr)
         exprt tmp=op;
         if(tmp.type()!=expr.type())
         {
-          tmp.make_typecast(expr.type());
+          tmp = typecast_exprt(tmp, expr.type());
           simplify_node(tmp);
         }
 
@@ -668,7 +667,7 @@ bool simplify_exprt::simplify_object_size(exprt &expr)
 
         if(size.type() != expr_type)
         {
-          size.make_typecast(expr_type);
+          size = typecast_exprt(size, expr_type);
           simplify_node(size);
         }