side_effect_exprt now offers constructor with operands

This removes the need to use .add_to_operands() after the construction of
the object.

Author: Daniel Kroening

src/cpp/cpp_constructor.cpp

@@ -141,8 +141,8 @@ optionalt<codet> cpp_typecheckt::cpp_constructor(
       // Override constantness
       object_tc.type().set(ID_C_constant, false);
       object_tc.set(ID_C_lvalue, true);
-      side_effect_exprt assign(ID_assign, typet(), source_location);
-      assign.copy_to_operands(object_tc, operands_tc.front());
+      side_effect_exprt assign(
+        ID_assign, {object_tc, operands_tc.front()}, typet(), source_location);
       typecheck_side_effect_assignment(assign);
       code_expressiont new_code;
       new_code.expression()=assign;
@@ -189,9 +189,14 @@ optionalt<codet> cpp_typecheckt::cpp_constructor(
       if(!component.get_bool(ID_from_base))
         val=true_exprt();
 
-      side_effect_exprt assign(ID_assign, typet(), source_location);
-      assign.add_to_operands(std::move(member), std::move(val));
+      side_effect_exprt assign(
+        ID_assign,
+        {std::move(member), std::move(val)},
+        typet(),
+        source_location);
+
       typecheck_side_effect_assignment(assign);
+
       block.add(code_expressiont(std::move(assign)));
     }
 

src/cpp/cpp_typecheck_code.cpp

@@ -314,8 +314,11 @@ void cpp_typecheckt::typecheck_member_initializer(codet &code)
         symbol_expr.set(ID_C_lvalue, true);
         code.op0().type().remove(ID_C_reference);
 
-        side_effect_exprt assign(ID_assign, typet(), code.source_location());
-        assign.copy_to_operands(symbol_expr, code.op0());
+        side_effect_exprt assign(
+          ID_assign,
+          {symbol_expr, code.op0()},
+          typet(),
+          code.source_location());
         typecheck_side_effect_assignment(assign);
         code_expressiont new_code(assign);
         code.swap(new_code);

src/cpp/parse.cpp

@@ -6403,8 +6403,8 @@ bool Parser::rPostfixExpr(exprt &exp)
       lex.get_token(op);
 
       {
-        side_effect_exprt tmp(ID_postdecrement, typet(), source_locationt());
-        tmp.add_to_operands(std::move(exp));
+        side_effect_exprt tmp(
+          ID_postdecrement, {std::move(exp)}, typet(), source_locationt());
         set_location(tmp, op);
         exp.swap(tmp);
       }

src/util/std_code.h

@@ -1557,7 +1557,7 @@ inline const code_expressiont &to_code_expression(const codet &code)
 /// subtypes are not subtypes of \ref codet, but they inherit directly from
 /// \ref exprt. They do have a `statement` like [codets](\ref codet), but their
 /// [id()](\ref irept::id) is `ID_side_effect`, not `ID_code`.
-class side_effect_exprt:public exprt
+class side_effect_exprt : public exprt
 {
 public:
   DEPRECATED("use side_effect_exprt(statement, type, loc) instead")
@@ -1567,8 +1567,8 @@ class side_effect_exprt:public exprt
   }
 
   DEPRECATED("use side_effect_exprt(statement, type, loc) instead")
-  side_effect_exprt(const irep_idt &statement, const typet &_type):
-    exprt(ID_side_effect, _type)
+  side_effect_exprt(const irep_idt &statement, const typet &_type)
+    : exprt(ID_side_effect, _type)
   {
     set_statement(statement);
   }
@@ -1583,6 +1583,19 @@ class side_effect_exprt:public exprt
     add_source_location() = loc;
   }
 
+  /// constructor with operands
+  side_effect_exprt(
+    const irep_idt &statement,
+    operandst &&_operands,
+    const typet &_type,
+    const source_locationt &loc)
+    : exprt(ID_side_effect, _type)
+  {
+    set_statement(statement);
+    operands() = std::move(_operands);
+    add_source_location() = loc;
+  }
+
   const irep_idt &get_statement() const
   {
     return get(ID_statement);
@@ -1735,9 +1748,12 @@ class side_effect_expr_function_callt:public side_effect_exprt
     const exprt::operandst &_arguments,
     const typet &_type,
     const source_locationt &loc)
-    : side_effect_exprt(ID_function_call, _type, loc)
+    : side_effect_exprt(
+        ID_function_call,
+        {_function, exprt(ID_arguments)},
+        _type,
+        loc)
   {
-    add_to_operands(_function, exprt(ID_arguments));
     arguments() = _arguments;
   }