introduce instructiont::assign_lhs() and assign_rhs()

jbmc/src/java_bytecode/remove_java_new.cpp

@@ -365,14 +365,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();
+    exprt lhs = target->assign_lhs();
+    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

@@ -162,9 +162,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())
@@ -768,14 +767,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

@@ -365,7 +365,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())
@@ -385,7 +385,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

@@ -905,8 +905,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

@@ -534,7 +534,7 @@ void code_contractst::instrument_assign_statement(
     "The first instruction of instrument_assign_statement should always be"
     " an assignment");
 
-  const exprt &lhs = instruction_iterator->get_assign().lhs();
+  const exprt &lhs = instruction_iterator->assign_lhs();
 
   goto_programt alias_assertion;
   alias_assertion.add(goto_programt::make_assertion(
@@ -573,7 +573,7 @@ void code_contractst::instrument_call_statement(
     local_instruction_iterator++;
     if(local_instruction_iterator->is_assign())
     {
-      const exprt &rhs = local_instruction_iterator->get_assign().rhs();
+      const exprt &rhs = local_instruction_iterator->assign_rhs();
       INVARIANT(
         rhs.id() == ID_typecast,
         "malloc is called but the result is not cast. Excluding result from "

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

@@ -107,8 +107,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(
@@ -286,7 +286,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);
@@ -301,10 +301,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))
@@ -347,12 +345,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);
@@ -467,14 +465,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

@@ -228,15 +228,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())
     {

src/goto-instrument/replace_calls.cpp

@@ -100,8 +100,7 @@ void replace_callst::operator()(
       goto_programt::const_targett next_it = std::next(it);
       if(next_it != goto_program.instructions.end() && next_it->is_assign())
       {
-        const code_assignt &ca = next_it->get_assign();
-        const exprt &rhs = ca.rhs();
+        const exprt &rhs = next_it->assign_rhs();
 
         INVARIANT(
           rhs != return_value_symbol(id, ns),

src/goto-instrument/rw_set.cpp

@@ -47,8 +47,7 @@ void _rw_set_loct::compute()
 {
   if(target->is_assign())
   {
-    const auto &assignment = target->get_assign();
-    assign(assignment.lhs(), assignment.rhs());
+    assign(target->assign_lhs(), target->assign_rhs());
   }
   else if(target->is_goto() ||
           target->is_assume() ||

src/goto-programs/goto_program.cpp

@@ -295,12 +295,9 @@ std::list<exprt> expressions_read(
   }
 
   case ASSIGN:
-  {
-    const code_assignt &assignment = instruction.get_assign();
-    dest.push_back(assignment.rhs());
-    parse_lhs_read(assignment.lhs(), dest);
+    dest.push_back(instruction.assign_rhs());
+    parse_lhs_read(instruction.assign_lhs(), dest);
     break;
-  }
 
   case CATCH:
   case THROW:
@@ -339,7 +336,7 @@ std::list<exprt> expressions_written(
     break;
 
   case ASSIGN:
-    dest.push_back(instruction.get_assign().lhs());
+    dest.push_back(instruction.assign_lhs());
     break;
 
   case CATCH:
@@ -931,15 +928,12 @@ void goto_programt::instructiont::transform(
 
   case ASSIGN:
   {
-    auto new_assign_lhs = f(get_assign().lhs());
-    auto new_assign_rhs = f(get_assign().rhs());
-    if(new_assign_lhs.has_value() || new_assign_rhs.has_value())
-    {
-      auto new_assignment = get_assign();
-      new_assignment.lhs() = new_assign_lhs.value_or(new_assignment.lhs());
-      new_assignment.rhs() = new_assign_rhs.value_or(new_assignment.rhs());
-      set_assign(new_assignment);
-    }
+    auto new_assign_lhs = f(assign_lhs());
+    auto new_assign_rhs = f(assign_rhs());
+    if(new_assign_lhs.has_value())
+      assign_lhs_nonconst() = new_assign_lhs.value();
+    if(new_assign_rhs.has_value())
+      assign_rhs_nonconst() = new_assign_rhs.value();
   }
   break;
 
@@ -1031,8 +1025,8 @@ void goto_programt::instructiont::apply(
     break;
 
   case ASSIGN:
-    f(get_assign().lhs());
-    f(get_assign().rhs());
+    f(assign_lhs());
+    f(assign_rhs());
     break;
 
   case DECL:

src/goto-programs/goto_program.h

@@ -194,13 +194,43 @@ class goto_programt
     }
 
     /// Get the assignment for ASSIGN
+    DEPRECATED(SINCE(2021, 2, 24, "Use assign_lhs/rhs instead"))
     const code_assignt &get_assign() const
     {
       PRECONDITION(is_assign());
       return to_code_assign(code);
     }
 
+    /// Get the lhs of the assignment for ASSIGN
+    const exprt &assign_lhs() const
+    {
+      PRECONDITION(is_assign());
+      return to_code_assign(code).lhs();
+    }
+
+    /// Get the lhs of the assignment for ASSIGN
+    exprt &assign_lhs_nonconst()
+    {
+      PRECONDITION(is_assign());
+      return to_code_assign(code).lhs();
+    }
+
+    /// Get the rhs of the assignment for ASSIGN
+    const exprt &assign_rhs() const
+    {
+      PRECONDITION(is_assign());
+      return to_code_assign(code).rhs();
+    }
+
+    /// Get the rhs of the assignment for ASSIGN
+    exprt &assign_rhs_nonconst()
+    {
+      PRECONDITION(is_assign());
+      return to_code_assign(code).rhs();
+    }
+
     /// Set the assignment for ASSIGN
+    DEPRECATED(SINCE(2021, 2, 24, "Use assign_lhs/rhs instead"))
     void set_assign(code_assignt c)
     {
       PRECONDITION(is_assign());

src/goto-programs/graphml_witness.cpp

@@ -231,9 +231,9 @@ static bool filter_out(
   goto_tracet::stepst::const_iterator &it)
 {
   if(
-    it->hidden && (!it->pc->is_assign() ||
-                   it->pc->get_assign().rhs().id() != ID_side_effect ||
-                   it->pc->get_assign().rhs().get(ID_statement) != ID_nondet))
+    it->hidden &&
+    (!it->pc->is_assign() || it->pc->assign_rhs().id() != ID_side_effect ||
+     it->pc->assign_rhs().get(ID_statement) != ID_nondet))
     return true;
 
   if(!it->is_assignment() && !it->is_goto() && !it->is_assert())