Replace make_typecast by typecast_exprt or typecast_exprt::conditional_cast

make_typecast is deprecated.

Author: tautschnig

jbmc/src/java_bytecode/java_bytecode_convert_method.cpp

@@ -2175,8 +2175,7 @@ void java_bytecode_convert_methodt::convert_invoke(
       type == java_byte_type() || type == java_short_type() ||
       type.id() == ID_pointer)
     {
-      if(type != arguments[i].type())
-        arguments[i].make_typecast(type);
+      arguments[i] = typecast_exprt::conditional_cast(arguments[i], type);
     }
   }
 

jbmc/src/java_bytecode/java_bytecode_instrument.cpp

@@ -225,9 +225,7 @@ code_ifthenelset java_bytecode_instrumentt::check_class_cast(
     class1, ID_java_instanceof, class2);
 
   pointer_typet voidptr=pointer_type(empty_typet());
-  exprt null_check_op=class1;
-  if(null_check_op.type()!=voidptr)
-    null_check_op.make_typecast(voidptr);
+  exprt null_check_op = typecast_exprt::conditional_cast(class1, voidptr);
 
   optionalt<codet> check_code;
   if(throw_runtime_exceptions)

src/ansi-c/ansi_c_entry_point.cpp

@@ -406,10 +406,10 @@ bool generate_ansi_c_start_function(
         zero_string.type().subtype()=char_type();
         zero_string.type().set(ID_size, "infinity");
         const index_exprt index(zero_string, from_integer(0, uint_type()));
-        exprt address_of=address_of_exprt(index, pointer_type(char_type()));
-
-        if(argv_symbol.type.subtype()!=address_of.type())
-          address_of.make_typecast(argv_symbol.type.subtype());
+        exprt address_of =
+          typecast_exprt::conditional_cast(
+            address_of_exprt(index, pointer_type(char_type())),
+            argv_symbol.type.subtype());
 
         // assign argv[*] to the address of a string-object
         array_of_exprt array_of(address_of, argv_symbol.type);

src/ansi-c/c_typecheck_expr.cpp

@@ -2598,10 +2598,11 @@ exprt c_typecheck_baset::do_special_functions(
       throw 0;
     }
 
-    expr.arguments()[0].make_typecast(bool_typet());
-    make_constant(expr.arguments()[0]);
+    exprt arg0 =
+      typecast_exprt::conditional_cast(expr.arguments()[0], bool_typet());
+    make_constant(arg0);
 
-    if(expr.arguments()[0].is_true())
+    if(arg0.is_true())
       return expr.arguments()[1];
     else
       return expr.arguments()[2];
@@ -2954,7 +2955,7 @@ void c_typecheck_baset::typecheck_expr_binary_arithmetic(exprt &expr)
     is_number(o_type1))
   {
     // convert op1 to the vector type
-    op1.make_typecast(o_type0);
+    op1 = typecast_exprt::conditional_cast(op1, o_type0);
     expr.type() = o_type0;
     return;
   }
@@ -2963,7 +2964,7 @@ void c_typecheck_baset::typecheck_expr_binary_arithmetic(exprt &expr)
     is_number(o_type0))
   {
     // convert op0 to the vector type
-    op0.make_typecast(o_type1);
+    op0 = typecast_exprt::conditional_cast(op0, o_type1);
     expr.type() = o_type1;
     return;
   }

src/cpp/cpp_typecheck_conversions.cpp

@@ -210,8 +210,7 @@ bool cpp_typecheckt::standard_conversion_integral_promotion(
     std::size_t width=to_signedbv_type(expr.type()).get_width();
     if(width >= config.ansi_c.int_width)
       return false;
-    new_expr=expr;
-    new_expr.make_typecast(int_type);
+    new_expr = typecast_exprt::conditional_cast(expr, int_type);
     return true;
   }
 
@@ -220,24 +219,21 @@ bool cpp_typecheckt::standard_conversion_integral_promotion(
     std::size_t width=to_unsignedbv_type(expr.type()).get_width();
     if(width >= config.ansi_c.int_width)
       return false;
-    new_expr=expr;
     if(width==config.ansi_c.int_width)
       int_type.id(ID_unsignedbv);
-    new_expr.make_typecast(int_type);
+    new_expr = typecast_exprt::conditional_cast(expr, int_type);
     return true;
   }
 
   if(expr.type().id() == ID_bool || expr.type().id() == ID_c_bool)
   {
-    new_expr = expr;
-    new_expr.make_typecast(int_type);
+    new_expr = typecast_exprt::conditional_cast(expr, int_type);
     return true;
   }
 
   if(expr.type().id()==ID_c_enum_tag)
   {
-    new_expr=expr;
-    new_expr.make_typecast(int_type);
+    new_expr = typecast_exprt::conditional_cast(expr, int_type);
     return true;
   }
 
@@ -271,8 +267,7 @@ bool cpp_typecheckt::standard_conversion_floating_point_promotion(
   c_qualifierst qual_from;
   qual_from.read(expr.type());
 
-  new_expr=expr;
-  new_expr.make_typecast(double_type());
+  new_expr = typecast_exprt::conditional_cast(expr, double_type());
   qual_from.write(new_expr.type());
 
   return true;
@@ -328,8 +323,7 @@ bool cpp_typecheckt::standard_conversion_integral_conversion(
 
   c_qualifierst qual_from;
   qual_from.read(expr.type());
-  new_expr=expr;
-  new_expr.make_typecast(type);
+  new_expr = typecast_exprt::conditional_cast(expr, type);
   qual_from.write(new_expr.type());
 
   return true;
@@ -382,8 +376,7 @@ bool cpp_typecheckt::standard_conversion_floating_integral_conversion(
 
   c_qualifierst qual_from;
   qual_from.read(expr.type());
-  new_expr=expr;
-  new_expr.make_typecast(type);
+  new_expr = typecast_exprt::conditional_cast(expr, type);
   qual_from.write(new_expr.type());
 
   return true;
@@ -425,8 +418,7 @@ bool cpp_typecheckt::standard_conversion_floating_point_conversion(
   c_qualifierst qual_from;
 
   qual_from.read(expr.type());
-  new_expr=expr;
-  new_expr.make_typecast(type);
+  new_expr = typecast_exprt::conditional_cast(expr, type);
   qual_from.write(new_expr.type());
 
   return true;
@@ -508,8 +500,7 @@ bool cpp_typecheckt::standard_conversion_pointer(
   {
     c_qualifierst qual_from;
     qual_from.read(expr.type().subtype());
-    new_expr=expr;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(expr, type);
     qual_from.write(new_expr.type().subtype());
     return true;
   }
@@ -614,8 +605,7 @@ bool cpp_typecheckt::standard_conversion_pointer_to_member(
   if(expr.id()==ID_constant &&
      expr.get(ID_value)==ID_NULL)
   {
-    new_expr=expr;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(expr, type);
     return true;
   }
 
@@ -627,8 +617,7 @@ bool cpp_typecheckt::standard_conversion_pointer_to_member(
 
   if(subtype_typecast(to_struct, from_struct))
   {
-    new_expr=expr;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(expr, type);
     return true;
   }
 
@@ -664,8 +653,7 @@ bool cpp_typecheckt::standard_conversion_boolean(
   typet Bool = c_bool_type();
   qual_from.write(Bool);
 
-  new_expr=expr;
-  new_expr.make_typecast(Bool);
+  new_expr = typecast_exprt::conditional_cast(expr, Bool);
   return true;
 }
 
@@ -705,7 +693,7 @@ bool cpp_typecheckt::standard_conversion_sequence(
 
   // we turn bit fields into their underlying type
   if(curr_expr.type().id()==ID_c_bit_field)
-    curr_expr.make_typecast(curr_expr.type().subtype());
+    curr_expr = typecast_exprt(curr_expr, curr_expr.type().subtype());
 
   if(curr_expr.type().id()==ID_array)
   {
@@ -791,7 +779,7 @@ bool cpp_typecheckt::standard_conversion_sequence(
       if(expr.type().subtype().id()==ID_nullptr)
       {
         // std::nullptr_t to _any_ pointer type is ok
-        new_expr.make_typecast(type);
+        new_expr = typecast_exprt::conditional_cast(new_expr, type);
       }
       else if(!standard_conversion_pointer(curr_expr, type, new_expr))
       {
@@ -1278,7 +1266,7 @@ bool cpp_typecheckt::reference_binding(
       {
         c_qualifierst qual_from;
         qual_from.read(expr.type());
-        new_expr.make_typecast(type);
+        new_expr = typecast_exprt::conditional_cast(new_expr, type);
         qual_from.write(new_expr.type().subtype());
       }
 
@@ -1805,8 +1793,7 @@ bool cpp_typecheckt::reinterpret_typecast(
      (type.id()==ID_unsignedbv || type.id()==ID_signedbv))
   {
     // pointer to integer, always ok
-    new_expr=e;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(e, type);
     return true;
   }
 
@@ -1825,8 +1812,7 @@ bool cpp_typecheckt::reinterpret_typecast(
     }
     else
     {
-      new_expr=e;
-      new_expr.make_typecast(type);
+      new_expr = typecast_exprt::conditional_cast(e, type);
     }
     return true;
   }
@@ -1837,16 +1823,13 @@ bool cpp_typecheckt::reinterpret_typecast(
   {
     // pointer to pointer: we ok it all.
     // This is more generous than the standard.
-    new_expr=expr;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(expr, type);
     return true;
   }
 
   if(is_reference(type) && e.get_bool(ID_C_lvalue))
   {
-    exprt tmp=address_of_exprt(e);
-    tmp.make_typecast(type);
-    new_expr.swap(tmp);
+    new_expr = typecast_exprt::conditional_cast(address_of_exprt(e), type);
     return true;
   }
 
@@ -1919,8 +1902,7 @@ bool cpp_typecheckt::static_typecast(
 
   if(type.id()==ID_empty)
   {
-    new_expr=e;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(e, type);
     return true;
   }
 
@@ -1930,8 +1912,7 @@ bool cpp_typecheckt::static_typecast(
       e.type().id()==ID_unsignedbv ||
       e.type().id()==ID_c_enum_tag))
   {
-    new_expr=e;
-    new_expr.make_typecast(type);
+    new_expr = typecast_exprt::conditional_cast(e, type);
     new_expr.remove(ID_C_lvalue);
     return true;
   }
@@ -1966,9 +1947,8 @@ bool cpp_typecheckt::static_typecast(
 
       if(from.id()==ID_empty)
       {
-          e.make_typecast(type);
-          new_expr.swap(e);
-          return true;
+        new_expr = typecast_exprt::conditional_cast(e, type);
+        return true;
       }
 
       if(to.id()==ID_struct && from.id()==ID_struct)
@@ -2007,8 +1987,7 @@ bool cpp_typecheckt::static_typecast(
 
       if(subtype_typecast(from_struct, to_struct))
       {
-        new_expr=e;
-        new_expr.make_typecast(type);
+        new_expr = typecast_exprt::conditional_cast(e, type);
         return true;
       }
     }

src/cpp/cpp_typecheck_initializer.cpp

@@ -296,8 +296,8 @@ void cpp_typecheckt::zero_initializer(
     const unsignedbv_typet enum_type(
       to_bitvector_type(final_type.subtype()).get_width());
 
-    exprt zero(from_integer(0, enum_type));
-    zero.make_typecast(type);
+    exprt zero =
+      typecast_exprt::conditional_cast(from_integer(0, enum_type), type);
     already_typechecked(zero);
 
     code_assignt assign;

src/cpp/cpp_typecheck_static_assert.cpp

@@ -19,7 +19,8 @@ void cpp_typecheckt::convert(cpp_static_assertt &cpp_static_assert)
   typecheck_expr(cpp_static_assert.op0());
   typecheck_expr(cpp_static_assert.op1());
 
-  cpp_static_assert.op0().make_typecast(bool_typet());
+  cpp_static_assert.op0() =
+    typecast_exprt::conditional_cast(cpp_static_assert.op0(), bool_typet());
   make_constant(cpp_static_assert.op0());
 
   if(cpp_static_assert.op0().is_true())

src/goto-cc/linker_script_merge.cpp

@@ -576,8 +576,8 @@ int linker_script_merget::ls_data2instructions(
         unsigned_int_type().get_width()),
       unsigned_int_type());
 
-    exprt rhs_tc(rhs);
-    rhs_tc.make_typecast(pointer_type(char_type()));
+    exprt rhs_tc =
+      typecast_exprt::conditional_cast(rhs, pointer_type(char_type()));
 
     linker_values.emplace(
       irep_idt(d["sym"].value), std::make_pair(lhs, rhs_tc));
@@ -640,8 +640,8 @@ int linker_script_merget::ls_data2instructions(
       string2integer(d["val"].value), unsigned_int_type().get_width()));
     rhs.type()=unsigned_int_type();
 
-    exprt rhs_tc(rhs);
-    rhs_tc.make_typecast(pointer_type(char_type()));
+    exprt rhs_tc =
+      typecast_exprt::conditional_cast(rhs, pointer_type(char_type()));
 
     linker_values.emplace(
       irep_idt(d["sym"].value), std::make_pair(lhs, rhs_tc));

src/goto-instrument/goto_program2code.cpp

@@ -1846,7 +1846,7 @@ void goto_program2codet::cleanup_expr(exprt &expr, bool no_typecast)
 
     const typet &t=expr.type();
 
-    expr.make_typecast(t);
+    expr = typecast_exprt(expr, t);
     add_local_types(t);
 
     const irep_idt &typedef_str=expr.type().get(ID_C_typedef);
@@ -1944,10 +1944,10 @@ void goto_program2codet::cleanup_expr(exprt &expr, bool no_typecast)
     else if(expr.type().id()==ID_bool ||
             expr.type().id()==ID_c_bool)
     {
-      expr=from_integer(
-        expr.is_true()?1:0,
-        signedbv_typet(config.ansi_c.int_width));
-      expr.make_typecast(bool_typet());
+      expr = typecast_exprt(
+        from_integer(
+          expr.is_true() ? 1 : 0, signedbv_typet(config.ansi_c.int_width)),
+        bool_typet());
     }
 
     const irept &c_sizeof_type=expr.find(ID_C_c_sizeof_type);