Use appropriate numeric_cast_v<T> instead of deprecated integer2unsigned

This includes several type fixes - only three instances ended up as
numeric_cast_v<unsigned>, all others uses of integer2unsigned were actually in
contexts where some other type was required.

Author: tautschnig

src/ansi-c/expr2c.cpp

@@ -2219,10 +2219,7 @@ std::string expr2ct::convert_array(
       if(it==--src.operands().end())
         break;
 
-      assert(it->is_constant());
-      mp_integer i;
-      to_integer(*it, i);
-      unsigned int ch=integer2unsigned(i);
+      const unsigned int ch = numeric_cast_v<unsigned>(*it);
 
       if(last_was_hex)
       {

src/solvers/flattening/boolbv.cpp

@@ -74,7 +74,8 @@ bool boolbvt::literal(
       if(to_integer(index_expr.index(), index))
         throw "literal expects constant index";
 
-      std::size_t offset=integer2unsigned(index*element_width);
+      const std::size_t offset =
+        numeric_cast_v<std::size_t>(index * element_width);
 
       return literal(index_expr.array(), bit+offset, dest);
     }
@@ -358,7 +359,7 @@ bvt boolbvt::convert_lambda(const exprt &expr)
 
     const bvt &tmp=convert_bv(expr_op1);
 
-    std::size_t offset=integer2unsigned(i*tmp.size());
+    const std::size_t offset = numeric_cast_v<std::size_t>(i * tmp.size());
 
     if(size*tmp.size()!=width)
       throw "convert_lambda: unexpected operand width";

src/solvers/flattening/boolbv_byte_update.cpp

@@ -60,7 +60,7 @@ bvt boolbvt::convert_byte_update(const byte_update_exprt &expr)
         bv_endianness_mapt map_op(op.type(), false, ns, boolbv_width);
         bv_endianness_mapt map_value(value.type(), false, ns, boolbv_width);
 
-        std::size_t offset_i=integer2unsigned(offset);
+        const std::size_t offset_i = numeric_cast_v<std::size_t>(offset);
 
         for(std::size_t i=0; i<update_width; i++)
         {

src/solvers/flattening/boolbv_extractbits.cpp

@@ -61,7 +61,7 @@ bvt boolbvt::convert_extractbits(const extractbits_exprt &expr)
     throw 0;
   }
 
-  std::size_t offset=integer2unsigned(o2);
+  const std::size_t offset = numeric_cast_v<std::size_t>(o2);
 
   bvt bv;
   bv.resize(width);

src/solvers/flattening/boolbv_replication.cpp

@@ -24,7 +24,7 @@ bvt boolbvt::convert_replication(const replication_exprt &expr)
   bvt bv;
   bv.resize(width);
 
-  const std::size_t u_times=integer2unsigned(times);
+  const std::size_t u_times = numeric_cast_v<std::size_t>(times);
   const bvt &op=convert_bv(expr.op1());
   std::size_t offset=0;
 

src/solvers/flattening/boolbv_width.cpp

@@ -144,7 +144,7 @@ const boolbv_widtht::entryt &boolbv_widtht::get_entry(const typet &type) const
       if(total>(1<<30)) // realistic limit
         throw "array too large for flattening";
 
-      entry.total_width=integer2unsigned(total);
+      entry.total_width = numeric_cast_v<std::size_t>(total);
     }
   }
   else if(type_id==ID_vector)
@@ -165,13 +165,13 @@ const boolbv_widtht::entryt &boolbv_widtht::get_entry(const typet &type) const
       if(total>(1<<30)) // realistic limit
         throw "vector too large for flattening";
 
-      entry.total_width=integer2unsigned(vector_size*sub_width);
+      entry.total_width = numeric_cast_v<std::size_t>(vector_size * sub_width);
     }
   }
   else if(type_id==ID_complex)
   {
-    std::size_t sub_width=operator()(type.subtype());
-    entry.total_width=integer2unsigned(2*sub_width);
+    const mp_integer sub_width = operator()(type.subtype());
+    entry.total_width = numeric_cast_v<std::size_t>(2 * sub_width);
   }
   else if(type_id==ID_code)
   {

src/solvers/flattening/boolbv_with.cpp

@@ -146,7 +146,8 @@ void boolbvt::convert_with_array(
 
     if(op1_value>=0 && op1_value<size) // bounds check
     {
-      std::size_t offset=integer2unsigned(op1_value*op2_bv.size());
+      const std::size_t offset =
+        numeric_cast_v<std::size_t>(op1_value * op2_bv.size());
 
       for(std::size_t j=0; j<op2_bv.size(); j++)
         next_bv[offset+j]=op2_bv[j];
@@ -163,7 +164,7 @@ void boolbvt::convert_with_array(
 
     literalt eq_lit=convert(equal_exprt(op1, counter));
 
-    std::size_t offset=integer2unsigned(i*op2_bv.size());
+    const std::size_t offset = numeric_cast_v<std::size_t>(i * op2_bv.size());
 
     for(std::size_t j=0; j<op2_bv.size(); j++)
       next_bv[offset+j]=

src/solvers/flattening/flatten_byte_operators.cpp

@@ -315,7 +315,7 @@ exprt flatten_byte_extract(
   const typet &offset_type=ns.follow(offset.type());
 
   // get 'width'-many bytes, and concatenate
-  std::size_t width_bytes=integer2unsigned(num_elements);
+  const std::size_t width_bytes = numeric_cast_v<std::size_t>(num_elements);
   exprt::operandst op;
   op.reserve(width_bytes);
 
@@ -543,11 +543,13 @@ exprt flatten_byte_update(
     // zero-extend the value, but only if needed
     exprt value_extended;
 
-    if(width>integer2unsigned(element_size)*8)
+    if(width > element_size * 8)
       value_extended=
         concatenation_exprt(
           from_integer(
-            0, unsignedbv_typet(width-integer2unsigned(element_size)*8)),
+            0,
+            unsignedbv_typet(
+              width - numeric_cast_v<std::size_t>(element_size * 8))),
           src.op2(), t);
     else
       value_extended=src.op2();

src/solvers/qbf/qbf_qube_core.cpp

@@ -12,6 +12,7 @@ Author: CM Wintersteiger
 #include <cstring>
 #include <fstream>
 
+#include <util/arith_tools.h>
 #include <util/invariant.h>
 #include <util/mp_arith.h>
 
@@ -78,9 +79,9 @@ propt::resultt qbf_qube_coret::prop_solve()
       {
         mp_integer b(line.substr(2).c_str());
         if(b<0)
-          assignment[integer2unsigned(b.negate())]=false;
+          assignment[numeric_cast_v<std::size_t>(b.negate())] = false;
         else
-          assignment[integer2unsigned(b)]=true;
+          assignment[numeric_cast_v<std::size_t>(b)] = true;
       }
       else if(line=="s cnf 1")
       {

src/util/arith_tools.cpp

@@ -100,7 +100,7 @@ bool to_unsigned_integer(const constant_exprt &expr, unsigned &uint_value)
     return true;
   else
   {
-    uint_value=integer2unsigned(i);
+    uint_value = numeric_cast_v<unsigned>(i);
     return false;
   }
 }

src/util/config.cpp

@@ -1136,7 +1136,7 @@ static unsigned unsigned_from_ns(
     "symbol table configuration entry `" + id2string(id) +
       "' must be convertible to mp_integer");
 
-  return integer2unsigned(int_value);
+  return numeric_cast_v<unsigned>(int_value);
 }
 
 void configt::set_from_symbol_table(

src/util/string_constant.cpp

@@ -87,13 +87,12 @@ bool string_constantt::from_array_expr(const array_exprt &src)
 
   std::string value;
 
-  forall_operands(it, src)
+  for(const auto &op : src.operands())
   {
-    mp_integer int_value=0;
-    if(to_integer(*it, int_value))
+    if(!op.is_constant())
       return true;
-    unsigned unsigned_value=integer2unsigned(int_value);
-    value+=static_cast<char>(unsigned_value);
+
+    value += numeric_cast_v<char>(op);
   }
 
   // Drop the implicit zero at the end.