avoid use of deprecated expression constructors

The constructors have been deprecated since Nov 2019 or earlier, and there
are straight-forward replacements.

Author: Daniel Kroening

src/analyses/goto_check.cpp

@@ -829,8 +829,8 @@ void goto_checkt::integer_overflow_check(
     return;
   }
 
-  multi_ary_exprt overflow("overflow-" + expr.id_string(), bool_typet());
-  overflow.operands()=expr.operands();
+  multi_ary_exprt overflow(
+    "overflow-" + expr.id_string(), expr.operands(), bool_typet());
 
   if(expr.operands().size()>=3)
   {

src/goto-instrument/accelerate/overflow_instrumenter.cpp

@@ -211,8 +211,8 @@ void overflow_instrumentert::overflow_expr(
           expr.id()==ID_mult)
   {
     // A generic arithmetic operation.
-    multi_ary_exprt overflow("overflow-" + expr.id_string(), bool_typet());
-    overflow.operands()=expr.operands();
+    multi_ary_exprt overflow(
+      "overflow-" + expr.id_string(), expr.operands(), bool_typet());
 
     if(expr.operands().size()>=3)
     {

src/goto-symex/field_sensitivity.cpp

@@ -154,8 +154,8 @@ exprt field_sensitivityt::get_fields(
     const struct_typet &type = to_struct_type(ns.follow(ssa_expr.type()));
     const struct_union_typet::componentst &components = type.components();
 
-    struct_exprt result(ssa_expr.type());
-    result.reserve_operands(components.size());
+    struct_exprt::operandst fields;
+    fields.reserve(components.size());
 
     const exprt &struct_op = ssa_expr.get_original_expr();
 
@@ -168,14 +168,13 @@ exprt field_sensitivityt::get_fields(
       tmp.set_expression(member);
       if(was_l2)
       {
-        result.add_to_operands(
-          state.rename(get_fields(ns, state, tmp), ns).get());
+        fields.push_back(state.rename(get_fields(ns, state, tmp), ns).get());
       }
       else
-        result.add_to_operands(get_fields(ns, state, tmp));
+        fields.push_back(get_fields(ns, state, tmp));
     }
 
-    return std::move(result);
+    return struct_exprt(std::move(fields), ssa_expr.type());
   }
 #ifdef ENABLE_ARRAY_FIELD_SENSITIVITY
   else if(
@@ -190,8 +189,8 @@ exprt field_sensitivityt::get_fields(
     const array_typet &type = to_array_type(ssa_expr.type());
     const std::size_t array_size = numeric_cast_v<std::size_t>(mp_array_size);
 
-    array_exprt result(type);
-    result.reserve_operands(array_size);
+    array_exprt::operandst elements;
+    elements.reserve(array_size);
 
     const exprt &array = ssa_expr.get_original_expr();
 
@@ -204,14 +203,13 @@ exprt field_sensitivityt::get_fields(
       tmp.set_expression(index);
       if(was_l2)
       {
-        result.add_to_operands(
-          state.rename(get_fields(ns, state, tmp), ns).get());
+        elements.push_back(state.rename(get_fields(ns, state, tmp), ns).get());
       }
       else
-        result.add_to_operands(get_fields(ns, state, tmp));
+        elements.push_back(get_fields(ns, state, tmp));
     }
 
-    return std::move(result);
+    return array_exprt(std::move(elements), type);
   }
 #endif // ENABLE_ARRAY_FIELD_SENSITIVITY
   else

src/goto-symex/goto_symex.cpp

@@ -1019,8 +1019,8 @@ bool goto_symext::constant_propagate_replace(
   auto &new_data = f_l1.arguments().at(4);
   auto &old_data = f_l1.arguments().at(3);
 
-  array_exprt characters_to_find(s_data_opt->get().type());
-  array_exprt characters_to_replace(s_data_opt->get().type());
+  array_exprt::operandst characters_to_find;
+  array_exprt::operandst characters_to_replace;
 
   // Two main ways to perform a replace: characters or strings.
   bool is_single_character = new_data.type().id() == ID_unsignedbv &&
@@ -1035,8 +1035,8 @@ bool goto_symext::constant_propagate_replace(
       return {};
     }
 
-    characters_to_find.operands().emplace_back(old_char_pointer->get());
-    characters_to_replace.operands().emplace_back(new_char_pointer->get());
+    characters_to_find.emplace_back(old_char_pointer->get());
+    characters_to_replace.emplace_back(new_char_pointer->get());
   }
   else
   {
@@ -1054,23 +1054,23 @@ bool goto_symext::constant_propagate_replace(
       return {};
     }
 
-    characters_to_find = old_char_array_opt->get();
-    characters_to_replace = new_char_array_opt->get();
+    characters_to_find = old_char_array_opt->get().operands();
+    characters_to_replace = new_char_array_opt->get().operands();
   }
 
   // Copy data, then do initial search for a replace sequence.
   array_exprt existing_data = s_data_opt->get();
   auto found_pattern = std::search(
     existing_data.operands().begin(),
     existing_data.operands().end(),
-    characters_to_find.operands().begin(),
-    characters_to_find.operands().end());
+    characters_to_find.begin(),
+    characters_to_find.end());
 
   // If we've found a match, proceed to perform a replace on all instances.
   while(found_pattern != existing_data.operands().end())
   {
     // Find the difference between our first/last match iterator.
-    auto match_end = found_pattern + characters_to_find.operands().size();
+    auto match_end = found_pattern + characters_to_find.size();
 
     // Erase them.
     found_pattern = existing_data.operands().erase(found_pattern, match_end);
@@ -1079,16 +1079,16 @@ bool goto_symext::constant_propagate_replace(
     // our new sequence.
     found_pattern = existing_data.operands().insert(
                       found_pattern,
-                      characters_to_replace.operands().begin(),
-                      characters_to_replace.operands().end()) +
-                    characters_to_replace.operands().size();
+                      characters_to_replace.begin(),
+                      characters_to_replace.end()) +
+                    characters_to_replace.size();
 
     // Then search from there for any additional matches.
     found_pattern = std::search(
       found_pattern,
       existing_data.operands().end(),
-      characters_to_find.operands().begin(),
-      characters_to_find.operands().end());
+      characters_to_find.begin(),
+      characters_to_find.end());
   }
 
   const constant_exprt new_char_array_length =

unit/goto-symex/expr_skeleton.cpp

@@ -23,7 +23,7 @@ SCENARIO("expr skeleton", "[core][goto-symex][symex-assign][expr-skeleton]")
     const signedbv_typet int_type{32};
     const expr_skeletont index_skeleton =
       expr_skeletont::remove_op0(index_exprt{
-        array_exprt{array_typet{int_type, from_integer(2, size_type())}},
+        array_exprt{{}, array_typet{int_type, from_integer(2, size_type())}},
         from_integer(1, size_type())});
     const expr_skeletont member_skeleton = expr_skeletont::remove_op0(
       member_exprt{symbol_exprt{"struct1", typet{}}, "field1", int_type});

unit/goto-symex/symex_assign.cpp

@@ -248,8 +248,7 @@ SCENARIO(
             member_exprt{struct1_sym, "field1", int_type}};
           struct1_v0_field1.set_level_0(0);
           struct1_v0_field1.set_level_2(0);
-          struct_exprt struct_expr(struct_type);
-          struct_expr.add_to_operands(struct1_v0_field1);
+          struct_exprt struct_expr({struct1_v0_field1}, struct_type);
           with_exprt struct1_v0_with_field_set = rhs;
           struct1_v0_with_field_set.old() = struct_expr;
           REQUIRE(assign_step.ssa_rhs == struct1_v0_with_field_set);