introduce instructiont::assign_lhs() and assign_rhs()

This mirrors the change in #5861 by replacing the use of code_assignt by
directly returning the lhs and rhs expressions.  The client code is
simplified.

Author: kroening

jbmc/src/java_bytecode/remove_java_new.cpp

@@ -364,14 +364,12 @@ goto_programt::targett remove_java_newt::lower_java_new(
   if(!target->is_assign())
     return target;
 
-  if(as_const(*target).get_assign().rhs().id() == ID_side_effect)
+  if(as_const(*target).assign_rhs().id() == ID_side_effect)
   {
     // we make a copy, as we intend to destroy the assignment
     // inside lower_java_new and lower_java_new_array
-    const auto code_assign = target->get_assign();
-
-    const exprt &lhs = code_assign.lhs();
-    const exprt &rhs = code_assign.rhs();
+    const exprt &lhs = target->assign_lhs();
+    const exprt &rhs = target->assign_rhs();
 
     const auto &side_effect_expr = to_side_effect_expr(rhs);
     const auto &statement = side_effect_expr.get_statement();

src/analyses/constant_propagator.cpp

@@ -163,9 +163,8 @@ void constant_propagator_domaint::transform(
   }
   else if(from->is_assign())
   {
-    const auto &assignment = from->get_assign();
-    const exprt &lhs=assignment.lhs();
-    const exprt &rhs=assignment.rhs();
+    const exprt &lhs = from->assign_lhs();
+    const exprt &rhs = from->assign_rhs();
     assign_rec(values, lhs, rhs, ns, cp, true);
   }
   else if(from->is_assume())
@@ -769,14 +768,12 @@ void constant_propagator_ait::replace(
     }
     else if(it->is_assign())
     {
-      auto assign = it->get_assign();
-      exprt &rhs = assign.rhs();
+      exprt &rhs = it->assign_rhs_nonconst();
 
       if(!constant_propagator_domaint::partial_evaluate(d.values, rhs, ns))
       {
         if(rhs.id() == ID_constant)
-          rhs.add_source_location() = assign.lhs().source_location();
-        it->set_assign(assign);
+          rhs.add_source_location() = it->assign_lhs().source_location();
       }
     }
     else if(it->is_function_call())

src/goto-analyzer/static_simplifier.cpp

@@ -107,26 +107,21 @@ bool static_simplifier(
       }
       else if(i_it->is_assign())
       {
-        auto assign = i_it->get_assign();
-
         // Simplification needs to be aware of which side of the
         // expression it is handling as:
         // <i=0, j=1>  i=j
         // should simplify to i=1, not to 0=1.
 
-        bool unchanged_lhs =
-          ai.abstract_state_before(i_it)->ai_simplify_lhs(assign.lhs(), ns);
+        bool unchanged_lhs = ai.abstract_state_before(i_it)->ai_simplify_lhs(
+          i_it->assign_lhs_nonconst(), ns);
 
-        bool unchanged_rhs =
-          ai.abstract_state_before(i_it)->ai_simplify(assign.rhs(), ns);
+        bool unchanged_rhs = ai.abstract_state_before(i_it)->ai_simplify(
+          i_it->assign_rhs_nonconst(), ns);
 
         if(unchanged_lhs && unchanged_rhs)
           unmodified.assigns++;
         else
-        {
           simplified.assigns++;
-          i_it->set_assign(assign);
-        }
       }
       else if(i_it->is_function_call())
       {

src/goto-instrument/accelerate/accelerate.cpp

@@ -367,7 +367,7 @@ void acceleratet::add_dirty_checks()
     // variables is clean _before_ clearing any dirty flags.
     if(it->is_assign())
     {
-      const exprt &lhs = it->get_assign().lhs();
+      const exprt &lhs = it->assign_lhs();
       expr_mapt::iterator dirty_var=dirty_vars_map.find(lhs);
 
       if(dirty_var!=dirty_vars_map.end())
@@ -387,7 +387,7 @@ void acceleratet::add_dirty_checks()
 
     if(it->is_assign())
     {
-      find_symbols_or_nexts(it->get_assign().rhs(), read);
+      find_symbols_or_nexts(it->assign_rhs(), read);
     }
 
     for(find_symbols_sett::iterator jt=read.begin();

src/goto-instrument/accelerate/acceleration_utils.cpp

@@ -915,8 +915,8 @@ bool acceleration_utilst::do_nonrecursive(
   {
     if(it->is_assign())
     {
-      exprt lhs = it->get_assign().lhs();
-      exprt rhs = it->get_assign().rhs();
+      exprt lhs = it->assign_lhs();
+      exprt rhs = it->assign_rhs();
 
       if(lhs.id()==ID_dereference)
       {

src/goto-instrument/code_contracts.cpp

@@ -392,7 +392,7 @@ void code_contractst::instrument_assigns_statement(
     instruction_iterator->is_assign(),
     "The first argument of instrument_assigns_statement should always be"
     " an assignment");
-  const exprt &lhs = instruction_iterator->get_assign().lhs();
+  const exprt &lhs = instruction_iterator->assign_lhs();
   if(freely_assignable_exprs.find(lhs) != freely_assignable_exprs.end())
   {
     return;
@@ -434,10 +434,9 @@ void code_contractst::instrument_call_statement(
     local_instruction_iterator++;
     if(
       local_instruction_iterator->is_assign() &&
-      local_instruction_iterator->get_assign().lhs().is_not_nil())
+      local_instruction_iterator->assign_lhs().is_not_nil())
     {
-      freely_assignable_exprs.insert(
-        local_instruction_iterator->get_assign().lhs());
+      freely_assignable_exprs.insert(local_instruction_iterator->assign_lhs());
     }
     return; // assume malloc edits no currently-existing memory objects.
   }

src/goto-instrument/concurrency.cpp

@@ -108,8 +108,7 @@ void concurrency_instrumentationt::instrument(
   {
     if(it->is_assign())
     {
-      code_assignt &code = to_code_assign(it->code_nonconst());
-      instrument(code.rhs());
+      instrument(it->assign_rhs_nonconst());
     }
     else if(it->is_assume() || it->is_assert() || it->is_goto())
     {

src/goto-instrument/count_eloc.cpp

@@ -173,9 +173,8 @@ void print_global_state_size(const goto_modelt &goto_model)
     {
       if(ins.is_assign())
       {
-        const code_assignt &code_assign = ins.get_assign();
         object_descriptor_exprt ode;
-        ode.build(code_assign.lhs(), ns);
+        ode.build(ins.assign_lhs(), ns);
 
         if(ode.root_object().id() == ID_symbol)
         {

src/goto-instrument/goto_program2code.cpp

@@ -108,8 +108,8 @@ void goto_program2codet::scan_for_varargs()
   {
     if(instruction.is_assign())
     {
-      const exprt &l = instruction.get_assign().lhs();
-      const exprt &r = instruction.get_assign().rhs();
+      const exprt &l = instruction.assign_lhs();
+      const exprt &r = instruction.assign_rhs();
 
       // find va_start
       if(
@@ -287,7 +287,7 @@ goto_programt::const_targett goto_program2codet::convert_assign(
   goto_programt::const_targett upper_bound,
   code_blockt &dest)
 {
-  const code_assignt &a = target->get_assign();
+  const code_assignt a{target->assign_lhs(), target->assign_rhs()};
 
   if(va_list_expr.find(a.lhs())!=va_list_expr.end())
     return convert_assign_varargs(target, upper_bound, dest);
@@ -302,10 +302,8 @@ goto_programt::const_targett goto_program2codet::convert_assign_varargs(
   goto_programt::const_targett upper_bound,
   code_blockt &dest)
 {
-  const code_assignt &assign = target->get_assign();
-
-  const exprt this_va_list_expr=assign.lhs();
-  const exprt &r=skip_typecast(assign.rhs());
+  const exprt this_va_list_expr = target->assign_lhs();
+  const exprt &r = skip_typecast(target->assign_rhs());
 
   if(r.id()==ID_constant &&
      (r.is_zero() || to_constant_expr(r).get_value()==ID_NULL))
@@ -348,12 +346,12 @@ goto_programt::const_targett goto_program2codet::convert_assign_varargs(
     if(next!=upper_bound &&
        next->is_assign())
     {
-      const exprt &n_r = next->get_assign().rhs();
+      const exprt &n_r = next->assign_rhs();
       if(
         n_r.id() == ID_dereference &&
         skip_typecast(to_dereference_expr(n_r).pointer()) == this_va_list_expr)
       {
-        f.lhs() = next->get_assign().lhs();
+        f.lhs() = next->assign_lhs();
 
         type_of.arguments().push_back(f.lhs());
         f.arguments().push_back(type_of);
@@ -468,14 +466,14 @@ goto_programt::const_targett goto_program2codet::convert_decl(
      !next->is_target() &&
      (next->is_assign() || next->is_function_call()))
   {
-    exprt lhs = next->is_assign() ? next->get_assign().lhs()
-                                  : next->get_function_call().lhs();
+    exprt lhs =
+      next->is_assign() ? next->assign_lhs() : next->get_function_call().lhs();
     if(lhs==symbol &&
        va_list_expr.find(lhs)==va_list_expr.end())
     {
       if(next->is_assign())
       {
-        d.set_initial_value({next->get_assign().rhs()});
+        d.set_initial_value({next->assign_rhs()});
       }
       else
       {

src/goto-instrument/nondet_volatile.cpp

@@ -226,15 +226,9 @@ void nondet_volatilet::nondet_volatile(
     if(instruction.is_assign())
     {
       nondet_volatile_rhs(
-        symbol_table,
-        to_code_assign(instruction.code_nonconst()).rhs(),
-        pre,
-        post);
+        symbol_table, instruction.assign_rhs_nonconst(), pre, post);
       nondet_volatile_lhs(
-        symbol_table,
-        to_code_assign(instruction.code_nonconst()).lhs(),
-        pre,
-        post);
+        symbol_table, instruction.assign_lhs_nonconst(), pre, post);
     }
     else if(instruction.is_function_call())
     {