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,13 +183,43 @@ class goto_programt
     codet code;
 
     /// Get the assignment for ASSIGN
+    DEPRECATED(SINCE(2021, 2, 24, "Use dead_symbol 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()
+    {
+      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
+    DEPRECATED(SINCE(2021, 2, 24, "Use dead_symbol instead"))
     void set_assign(code_assignt c)
     {
       PRECONDITION(is_assign());

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/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;

src/goto-programs/string_abstraction.cpp

@@ -515,7 +515,7 @@ goto_programt::targett string_abstractiont::abstract_assign(
     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);