Merge pull request #6381 from diffblue/cleanup_goto_program_api

remove 8 deprecated goto-program API methods

Author: kroening

jbmc/src/java_bytecode/replace_java_nondet.cpp

@@ -145,7 +145,7 @@ static bool is_assignment_from(
   {
     return false;
   }
-  const auto &rhs = instr.get_assign().rhs();
+  const auto &rhs = instr.assign_rhs();
   return is_symbol_with_id(rhs, identifier) ||
          is_typecast_with_id(rhs, identifier);
 }
@@ -223,7 +223,7 @@ static goto_programt::targett check_and_replace_target(
       "either have a variable for the return value in its lhs() or the next "
       "instruction should be an assignment of the return value to a temporary "
       "variable");
-    const exprt &return_value_assignment = next_instr->get_assign().lhs();
+    const exprt &return_value_assignment = next_instr->assign_lhs();
 
     // If the assignment is null, return.
     if(
@@ -285,7 +285,7 @@ static goto_programt::targett check_and_replace_target(
   else if(target_instruction->is_assign())
   {
     // Assume that the LHS of *this* assignment is the actual nondet variable
-    const auto &nondet_var = target_instruction->get_assign().lhs();
+    const auto &nondet_var = target_instruction->assign_lhs();
 
     side_effect_expr_nondett inserted_expr(
       nondet_var.type(), target_instruction->source_location);

jbmc/unit/java_bytecode/java_replace_nondet/replace_nondet.cpp

@@ -34,10 +34,10 @@ void validate_nondet_method_removed(
     // Check that our NONDET(<type>) exists on a rhs somewhere.
     if(inst.is_assign())
     {
-      const code_assignt &assignment = inst.get_assign();
-      if(assignment.rhs().id() == ID_side_effect)
+      const exprt &assignment_rhs = inst.assign_rhs();
+      if(assignment_rhs.id() == ID_side_effect)
       {
-        const side_effect_exprt &see = to_side_effect_expr(assignment.rhs());
+        const side_effect_exprt &see = to_side_effect_expr(assignment_rhs);
         if(see.get_statement() == ID_nondet)
         {
           replacement_nondet_exists = true;
@@ -92,7 +92,7 @@ void validate_nondets_converted(
     // Check that our NONDET(<type>) exists on a rhs somewhere.
     exprt target_expression =
       (inst.is_assign()
-         ? inst.get_assign().rhs()
+         ? inst.assign_rhs()
          : inst.is_set_return_value() ? inst.return_value() : inst.get_code());
 
     if(

src/analyses/custom_bitvector_analysis.cpp

@@ -286,10 +286,8 @@ void custom_bitvector_domaint::transform(
   switch(instruction.type)
   {
   case ASSIGN:
-    {
-      const code_assignt &code_assign = instruction.get_assign();
-      assign_struct_rec(from, code_assign.lhs(), code_assign.rhs(), cba, ns);
-    }
+    assign_struct_rec(
+      from, instruction.assign_lhs(), instruction.assign_rhs(), cba, ns);
     break;
 
   case DECL:

src/analyses/does_remove_const.cpp

@@ -39,20 +39,19 @@ std::pair<bool, source_locationt> does_remove_constt::operator()() const
       continue;
     }
 
-    const code_assignt &assign = instruction.get_assign();
-    const typet &rhs_type=assign.rhs().type();
-    const typet &lhs_type=assign.lhs().type();
+    const typet &rhs_type = instruction.assign_rhs().type();
+    const typet &lhs_type = instruction.assign_lhs().type();
 
     // Compare the types recursively for a point where the rhs is more
     // const that the lhs
     if(!does_type_preserve_const_correctness(&lhs_type, &rhs_type))
     {
-      return {true, assign.find_source_location()};
+      return {true, instruction.source_location};
     }
 
-    if(does_expr_lose_const(assign.rhs()))
+    if(does_expr_lose_const(instruction.assign_rhs()))
     {
-      return {true, assign.rhs().find_source_location()};
+      return {true, instruction.assign_rhs().find_source_location()};
     }
   }
 

src/analyses/escape_analysis.cpp

@@ -188,15 +188,16 @@ void escape_domaint::transform(
   {
   case ASSIGN:
     {
-      const code_assignt &code_assign = instruction.get_assign();
+      const exprt &assign_lhs = instruction.assign_lhs();
+      const exprt &assign_rhs = instruction.assign_rhs();
 
       std::set<irep_idt> cleanup_functions;
-      get_rhs_cleanup(code_assign.rhs(), cleanup_functions);
-      assign_lhs_cleanup(code_assign.lhs(), cleanup_functions);
+      get_rhs_cleanup(assign_rhs, cleanup_functions);
+      assign_lhs_cleanup(assign_lhs, cleanup_functions);
 
       std::set<irep_idt> rhs_aliases;
-      get_rhs_aliases(code_assign.rhs(), rhs_aliases);
-      assign_lhs_aliases(code_assign.lhs(), rhs_aliases);
+      get_rhs_aliases(assign_rhs, rhs_aliases);
+      assign_lhs_aliases(assign_lhs, rhs_aliases);
     }
     break;
 
@@ -461,17 +462,12 @@ void escape_analysist::instrument(
 
       if(instruction.type == ASSIGN)
       {
-        const code_assignt &code_assign = instruction.get_assign();
+        const exprt &assign_lhs = instruction.assign_lhs();
 
         std::set<irep_idt> cleanup_functions;
-        operator[](i_it).check_lhs(code_assign.lhs(), cleanup_functions);
+        operator[](i_it).check_lhs(assign_lhs, cleanup_functions);
         insert_cleanup(
-          gf_entry.second,
-          i_it,
-          code_assign.lhs(),
-          cleanup_functions,
-          false,
-          ns);
+          gf_entry.second, i_it, assign_lhs, cleanup_functions, false, ns);
       }
       else if(instruction.type == DEAD)
       {

src/analyses/global_may_alias.cpp

@@ -111,11 +111,9 @@ void global_may_alias_domaint::transform(
   {
   case ASSIGN:
   {
-    const code_assignt &code_assign = instruction.get_assign();
-
     std::set<irep_idt> rhs_aliases;
-    get_rhs_aliases(code_assign.rhs(), rhs_aliases);
-    assign_lhs_aliases(code_assign.lhs(), rhs_aliases);
+    get_rhs_aliases(instruction.assign_rhs(), rhs_aliases);
+    assign_lhs_aliases(instruction.assign_lhs(), rhs_aliases);
     break;
   }
 

src/analyses/goto_check.cpp

@@ -1982,33 +1982,30 @@ void goto_checkt::goto_check(
     }
     else if(i.is_assign())
     {
-      const code_assignt &code_assign = i.get_assign();
+      const exprt &assign_lhs = i.assign_lhs();
+      const exprt &assign_rhs = i.assign_rhs();
 
       // Reset the no_enum_check with the flag reset for exception
       // safety
       {
         flag_resett no_enum_check_flag_resetter;
         no_enum_check_flag_resetter.set_flag(no_enum_check, true);
-        check(code_assign.lhs());
+        check(assign_lhs);
       }
-      check(code_assign.rhs());
+
+      check(assign_rhs);
 
       // the LHS might invalidate any assertion
-      invalidate(code_assign.lhs());
+      invalidate(assign_lhs);
 
-      if(has_subexpr(code_assign.rhs(), [](const exprt &expr) {
+      if(has_subexpr(assign_rhs, [](const exprt &expr) {
            return expr.id() == ID_r_ok || expr.id() == ID_w_ok ||
                   expr.id() == ID_rw_ok;
          }))
       {
-        const exprt &rhs = i.get_assign().rhs();
-        auto rw_ok_cond = rw_ok_check(rhs);
+        auto rw_ok_cond = rw_ok_check(assign_rhs);
         if(rw_ok_cond.has_value())
-        {
-          auto new_assign = i.get_assign(); // copy
-          new_assign.rhs() = *rw_ok_cond;
-          i.set_assign(new_assign);
-        }
+          i.assign_rhs_nonconst() = *rw_ok_cond;
       }
     }
     else if(i.is_function_call())

src/analyses/goto_rw.cpp

@@ -717,16 +717,16 @@ void rw_guarded_range_set_value_sett::add(
     {range_start, {range_end, guard.as_expr()}});
 }
 
-static void goto_rw(
+static void goto_rw_assign(
   const irep_idt &function,
   goto_programt::const_targett target,
-  const code_assignt &assign,
+  const exprt &lhs,
+  const exprt &rhs,
   rw_range_sett &rw_set)
 {
   rw_set.get_objects_rec(
-    function, target, rw_range_sett::get_modet::LHS_W, assign.lhs());
-  rw_set.get_objects_rec(
-    function, target, rw_range_sett::get_modet::READ, assign.rhs());
+    function, target, rw_range_sett::get_modet::LHS_W, lhs);
+  rw_set.get_objects_rec(function, target, rw_range_sett::get_modet::READ, rhs);
 }
 
 static void goto_rw(
@@ -801,7 +801,8 @@ void goto_rw(
     break;
 
   case ASSIGN:
-    goto_rw(function, target, target->get_assign(), rw_set);
+    goto_rw_assign(
+      function, target, target->assign_lhs(), target->assign_rhs(), rw_set);
     break;
 
   case DEAD:

src/analyses/interval_domain.cpp

@@ -79,7 +79,7 @@ void interval_domaint::transform(
     break;
 
   case ASSIGN:
-    assign(instruction.get_assign());
+    assign(instruction.assign_lhs(), instruction.assign_rhs());
     break;
 
   case GOTO:
@@ -208,10 +208,10 @@ bool interval_domaint::join(
   return result;
 }
 
-void interval_domaint::assign(const code_assignt &code_assign)
+void interval_domaint::assign(const exprt &lhs, const exprt &rhs)
 {
-  havoc_rec(code_assign.lhs());
-  assume_rec(code_assign.lhs(), ID_equal, code_assign.rhs());
+  havoc_rec(lhs);
+  assume_rec(lhs, ID_equal, rhs);
 }
 
 void interval_domaint::havoc_rec(const exprt &lhs)

src/analyses/interval_domain.h

@@ -120,7 +120,7 @@ class interval_domaint:public ai_domain_baset
   void havoc_rec(const exprt &);
   void assume_rec(const exprt &, bool negation=false);
   void assume_rec(const exprt &lhs, irep_idt id, const exprt &rhs);
-  void assign(const class code_assignt &assignment);
+  void assign(const exprt &lhs, const exprt &rhs);
   integer_intervalt get_int_rec(const exprt &);
   ieee_float_intervalt get_float_rec(const exprt &);
 };