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

src/analyses/constant_propagator.cpp

@@ -164,9 +164,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())

src/goto-programs/goto_program.cpp

@@ -299,12 +299,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:
@@ -343,7 +340,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:
@@ -935,15 +932,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() = new_assign_lhs.value();
+    if(new_assign_rhs.has_value())
+      assign_rhs() = new_assign_rhs.value();
   }
   break;
 
@@ -1032,8 +1026,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

@@ -183,14 +183,44 @@ class goto_programt
     codet code;
 
     /// Get the assignment for ASSIGN
-    const code_assignt &get_assign() const
+    DEPRECATED(SINCE(2021, 2, 24, "Use dead_symbol instead"))
+    const code_assignt &get_assignX() 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()
+    {
+      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()
+    {
+      PRECONDITION(is_assign());
+      return to_code_assign(code).rhs();
+    }
+
     /// Set the assignment for ASSIGN
-    void set_assign(code_assignt c)
+    DEPRECATED(SINCE(2021, 2, 24, "Use dead_symbol instead"))
+    void set_assignX(code_assignt c)
     {
       PRECONDITION(is_assign());
       code = std::move(c);

src/goto-programs/graphml_witness.cpp

@@ -229,9 +229,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())

src/goto-programs/mm_io.cpp

@@ -45,8 +45,9 @@ void mm_io(
 
     if(it->is_assign())
     {
-      auto a = it->get_assign();
-      collect_deref_expr(a.rhs(), deref_expr_r);
+      auto &a_lhs = it->assign_lhs();
+      auto &a_rhs = it->assign_rhs();
+      collect_deref_expr(a_rhs, deref_expr_r);
 
       if(mm_io_r.is_not_nil())
       {
@@ -59,8 +60,7 @@ void mm_io(
           irep_idt identifier=to_symbol_expr(mm_io_r).get_identifier();
           auto return_value = return_value_symbol(identifier, ns);
           if_exprt if_expr(integer_address(d.pointer()), return_value, d);
-          if(!replace_expr(d, if_expr, a.rhs()))
-            it->set_assign(a);
+          replace_expr(d, if_expr, a_rhs);
 
           const typet &pt=ct.parameters()[0].type();
           const typet &st=ct.parameters()[1].type();
@@ -78,9 +78,9 @@ void mm_io(
 
       if(mm_io_w.is_not_nil())
       {
-        if(a.lhs().id()==ID_dereference)
+        if(a_lhs.id() == ID_dereference)
         {
-          const dereference_exprt &d=to_dereference_expr(a.lhs());
+          const dereference_exprt &d = to_dereference_expr(a_lhs);
           source_locationt source_location=it->source_location;
           const code_typet &ct=to_code_type(mm_io_w.type());
           const typet &pt=ct.parameters()[0].type();
@@ -92,7 +92,7 @@ void mm_io(
             mm_io_w,
             {typecast_exprt(d.pointer(), pt),
              typecast_exprt(size_opt.value(), st),
-             typecast_exprt(a.rhs(), vt)});
+             typecast_exprt(a_rhs, vt)});
           goto_function.body.insert_before_swap(it);
           *it = goto_programt::make_function_call(fc, source_location);
           it++;

src/goto-programs/remove_returns.cpp

@@ -310,14 +310,13 @@ bool remove_returnst::restore_returns(
   {
     if(instruction.is_assign())
     {
-      const auto &assign = instruction.get_assign();
-
-      if(assign.lhs().id()!=ID_symbol ||
-         to_symbol_expr(assign.lhs()).get_identifier()!=rv_name_id)
+      if(
+        instruction.assign_lhs().id() != ID_symbol ||
+        to_symbol_expr(instruction.assign_lhs()).get_identifier() != rv_name_id)
         continue;
 
       // replace "fkt#return_value=x;" by "return x;"
-      const exprt rhs = assign.rhs();
+      const exprt rhs = instruction.assign_rhs();
       instruction = goto_programt::make_return(
         code_returnt(rhs), instruction.source_location);
       did_something = true;
@@ -360,14 +359,12 @@ void remove_returnst::undo_function_calls(
       if(!next->is_assign())
         continue;
 
-      const code_assignt &assign = next->get_assign();
-
       const auto rv_symbol = return_value_symbol(function_id, ns);
-      if(assign.rhs() != rv_symbol)
+      if(next->assign_rhs() != rv_symbol)
         continue;
 
       // restore the previous assignment
-      function_call.lhs()=assign.lhs();
+      function_call.lhs() = next->assign_lhs();
 
       i_it->set_function_call(function_call);
 

src/goto-programs/restrict_function_pointers.cpp

@@ -413,17 +413,15 @@ function_pointer_restrictionst::get_by_name_restriction(
 
   const goto_programt::const_targett it = std::prev(location);
 
-  const code_assignt &assign = it->get_assign();
-
   INVARIANT(
-    to_symbol_expr(assign.lhs()).get_identifier() ==
+    to_symbol_expr(it->assign_lhs()).get_identifier() ==
       function_pointer_call_site.get_identifier(),
     "called function pointer must have been assigned at the previous location");
 
-  if(!can_cast_expr<symbol_exprt>(assign.rhs()))
+  if(!can_cast_expr<symbol_exprt>(it->assign_rhs()))
     return {};
 
-  const auto &rhs = to_symbol_expr(assign.rhs());
+  const auto &rhs = to_symbol_expr(it->assign_rhs());
 
   const auto restriction = by_name_restrictions.find(rhs.get_identifier());
 

src/goto-programs/slice_global_inits.cpp

@@ -93,8 +93,8 @@ void slice_global_inits(goto_modelt &goto_model)
     {
       if(!*seen_it && instruction.is_assign())
       {
-        const code_assignt &code_assign = instruction.get_assign();
-        const irep_idt id = to_symbol_expr(code_assign.lhs()).get_identifier();
+        const irep_idt id =
+          to_symbol_expr(instruction.assign_lhs()).get_identifier();
 
         // if we are to keep the left-hand side, then we also need to keep all
         // symbols occurring in the right-hand side
@@ -103,7 +103,7 @@ void slice_global_inits(goto_modelt &goto_model)
           symbols_to_keep.find(id) != symbols_to_keep.end())
         {
           fixed_point_reached = false;
-          find_symbols(code_assign.rhs(), symbols_to_keep, true, false);
+          find_symbols(instruction.assign_rhs(), symbols_to_keep, true, false);
           *seen_it = true;
         }
       }
@@ -119,8 +119,8 @@ void slice_global_inits(goto_modelt &goto_model)
   {
     if(instruction.is_assign())
     {
-      const code_assignt &code_assign = instruction.get_assign();
-      const symbol_exprt &symbol_expr=to_symbol_expr(code_assign.lhs());
+      const symbol_exprt &symbol_expr =
+        to_symbol_expr(instruction.assign_lhs());
       const irep_idt id=symbol_expr.get_identifier();
 
       if(

src/goto-programs/string_abstraction.cpp

@@ -498,10 +498,8 @@ goto_programt::targett string_abstractiont::abstract_assign(
   goto_programt::targett target)
 {
   {
-    code_assignt assign = target->get_assign();
-
-    exprt &lhs = assign.lhs();
-    exprt &rhs = assign.rhs();
+    exprt &lhs = target->assign_lhs();
+    exprt &rhs = target->assign_rhs();
 
     if(has_string_macros(lhs))
     {
@@ -511,11 +509,9 @@ goto_programt::targett string_abstractiont::abstract_assign(
 
     if(has_string_macros(rhs))
       replace_string_macros(rhs, false, target->source_location);
-
-    target->set_assign(assign);
   }
 
-  const typet &type = target->get_assign().lhs().type();
+  const typet &type = target->assign_lhs().type();
 
   if(type.id() == ID_pointer)
     return abstract_pointer_assign(dest, target);
@@ -1066,11 +1062,9 @@ goto_programt::targett string_abstractiont::abstract_pointer_assign(
   goto_programt &dest,
   const goto_programt::targett target)
 {
-  const code_assignt &assign = target->get_assign();
-
-  const exprt &lhs = assign.lhs();
-  const exprt rhs = assign.rhs();
-  const exprt *rhsp = &(assign.rhs());
+  const exprt &lhs = target->assign_lhs();
+  const exprt rhs = target->assign_rhs();
+  const exprt *rhsp = &(target->assign_rhs());
 
   while(rhsp->id()==ID_typecast)
     rhsp = &(to_typecast_expr(*rhsp).op());
@@ -1108,10 +1102,8 @@ goto_programt::targett string_abstractiont::abstract_char_assign(
   goto_programt &dest,
   goto_programt::targett target)
 {
-  const code_assignt &assign = target->get_assign();
-
-  const exprt &lhs = assign.lhs();
-  const exprt *rhsp = &(assign.rhs());
+  const exprt &lhs = target->assign_lhs();
+  const exprt *rhsp = &(target->assign_rhs());
 
   while(rhsp->id()==ID_typecast)
     rhsp = &(to_typecast_expr(*rhsp).op());