use typecast_exprt() instead of .make_typecast

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

Author: Daniel Kroening

src/ansi-c/c_typecast.cpp

@@ -734,16 +734,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_type.cpp

@@ -1019,7 +1019,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

@@ -1708,5 +1708,5 @@ void cpp_typecheckt::make_ptr_typecast(
   assert(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

@@ -1071,7 +1071,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

@@ -269,8 +269,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;
@@ -324,7 +323,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);
         }
 
@@ -673,7 +672,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);
         }