Refactor out new_tmp_symbol into utils

Author: SaswatPadhi

src/goto-instrument/contracts/contracts.cpp

@@ -169,14 +169,16 @@ void code_contractst::check_apply_loop_contracts(
   for(const auto &clause : decreases_clause.operands())
   {
     const auto old_decreases_var =
-      new_tmp_symbol(clause.type(), loop_head->source_location, mode)
+      new_tmp_symbol(
+        clause.type(), loop_head->source_location, mode, symbol_table)
         .symbol_expr();
     havoc_code.add(
       goto_programt::make_decl(old_decreases_var, loop_head->source_location));
     old_decreases_vars.push_back(old_decreases_var);
 
     const auto new_decreases_var =
-      new_tmp_symbol(clause.type(), loop_head->source_location, mode)
+      new_tmp_symbol(
+        clause.type(), loop_head->source_location, mode, symbol_table)
         .symbol_expr();
     havoc_code.add(
       goto_programt::make_decl(new_decreases_var, loop_head->source_location));
@@ -317,10 +319,8 @@ void code_contractst::add_quantified_variable(
       const auto &quantified_symbol = to_symbol_expr(quantified_variable);
 
       // 1. create fresh symbol
-      symbolt new_symbol = get_fresh_aux_symbol(
+      symbolt new_symbol = new_tmp_symbol(
         quantified_symbol.type(),
-        id2string(quantified_symbol.get_identifier()),
-        "tmp",
         quantified_symbol.source_location(),
         mode,
         symbol_table);
@@ -370,7 +370,8 @@ void code_contractst::replace_history_parameter(
         // 1. Create a temporary symbol expression that represents the
         // history variable
         symbol_exprt tmp_symbol =
-          new_tmp_symbol(parameter.type(), location, mode).symbol_expr();
+          new_tmp_symbol(parameter.type(), location, mode, symbol_table)
+            .symbol_expr();
 
         // 2. Associate the above temporary variable to it's corresponding
         // expression
@@ -609,20 +610,6 @@ void code_contractst::apply_loop_contract(
   }
 }
 
-const symbolt &code_contractst::new_tmp_symbol(
-  const typet &type,
-  const source_locationt &source_location,
-  const irep_idt &mode)
-{
-  return get_fresh_aux_symbol(
-    type,
-    id2string(source_location.get_function()) + "::tmp_cc",
-    "tmp_cc",
-    source_location,
-    mode,
-    symbol_table);
-}
-
 symbol_tablet &code_contractst::get_symbol_table()
 {
   return symbol_table;
@@ -962,7 +949,8 @@ void code_contractst::add_contract_check(
     symbol_exprt r = new_tmp_symbol(
                        code_type.return_type(),
                        skip->source_location,
-                       function_symbol.mode)
+                       function_symbol.mode,
+                       symbol_table)
                        .symbol_expr();
     check.add(goto_programt::make_decl(r, skip->source_location));
 
@@ -986,7 +974,8 @@ void code_contractst::add_contract_check(
     symbol_exprt p = new_tmp_symbol(
                        parameter_symbol.type,
                        skip->source_location,
-                       parameter_symbol.mode)
+                       parameter_symbol.mode,
+                       symbol_table)
                        .symbol_expr();
     check.add(goto_programt::make_decl(p, skip->source_location));
     check.add(goto_programt::make_assignment(

src/goto-instrument/contracts/contracts.h

@@ -96,11 +96,6 @@ class code_contractst
 
   void apply_loop_contracts();
 
-  const symbolt &new_tmp_symbol(
-    const typet &type,
-    const source_locationt &source_location,
-    const irep_idt &mode);
-
   void check_apply_loop_contracts(
     goto_functionst::goto_functiont &goto_function,
     const local_may_aliast &local_may_alias,

src/goto-instrument/contracts/utils.cpp

@@ -10,6 +10,7 @@ Date: September 2021
 
 #include "utils.h"
 
+#include <util/fresh_symbol.h>
 #include <util/pointer_expr.h>
 #include <util/pointer_predicates.h>
 
@@ -121,3 +122,18 @@ void insert_before_swap_and_advance(
   destination.insert_before_swap(target, payload);
   std::advance(target, offset);
 }
+
+const symbolt &new_tmp_symbol(
+  const typet &type,
+  const source_locationt &location,
+  const irep_idt &mode,
+  symbol_table_baset &symtab)
+{
+  return get_fresh_aux_symbol(
+    type,
+    id2string(location.get_function()) + "::tmp_cc",
+    "tmp_cc",
+    location,
+    mode,
+    symtab);
+}

src/goto-instrument/contracts/utils.h

@@ -53,10 +53,10 @@ class havoc_if_validt : public havoc_utilst
 /// over all dereferenced pointer expressions *(pexpr_1), *(pexpr_2), ...
 /// found in the AST of `expr`.
 ///
-/// \param expr The expression that contains dereferences to be validated
-/// \param ns The namespace that defines all symbols appearing in `expr`
+/// \param expr: The expression that contains dereferences to be validated.
+/// \param ns: The namespace that defines all symbols appearing in `expr`.
 /// \return A conjunctive expression that checks validity of all pointers
-///         that are dereferenced within `expr`
+///         that are dereferenced within `expr`.
 exprt all_dereferences_are_valid(const exprt &expr, const namespacet &ns);
 
 /// \brief Generate a lexicographic less-than comparison over ordered tuples
@@ -65,9 +65,9 @@ exprt all_dereferences_are_valid(const exprt &expr, const namespacet &ns);
 /// comparison, lhs < rhs, between two ordered tuples of variables.
 /// This is used in instrumentation of decreases clauses.
 ///
-/// \param lhs A vector of variables representing the LHS of the comparison
-/// \param rhs A vector of variables representing the RHS of the comparison
-/// \return A lexicographic less-than comparison expression: LHS < RHS
+/// \param lhs: A vector of variables representing the LHS of the comparison.
+/// \param rhs: A vector of variables representing the RHS of the comparison.
+/// \return A lexicographic less-than comparison expression: LHS < RHS.
 exprt generate_lexicographic_less_than_check(
   const std::vector<symbol_exprt> &lhs,
   const std::vector<symbol_exprt> &rhs);
@@ -81,12 +81,25 @@ exprt generate_lexicographic_less_than_check(
 /// After insertion, `target` is advanced by the size of the `payload`,
 /// and `payload` is destroyed.
 ///
-/// \param destination The destination program for inserting the `payload`
-/// \param target The instruction iterator at which to insert the `payload`
-/// \param payload The goto program to be inserted into the `destination`
+/// \param destination: The destination program for inserting the `payload`.
+/// \param target: The instruction iterator at which to insert the `payload`.
+/// \param payload: The goto program to be inserted into the `destination`.
 void insert_before_swap_and_advance(
   goto_programt &destination,
   goto_programt::targett &target,
   goto_programt &payload);
 
+/// \brief Adds a new temporary symbol to the symbol table.
+///
+/// \param type: The type of the new symbol.
+/// \param location: The source location for the new symbol.
+/// \param mode: The mode for the new symbol, e.g. ID_C, ID_java.
+/// \param symtab: The symbol table to which the new symbol is to be added.
+/// \return The new symbolt object.
+const symbolt &new_tmp_symbol(
+  const typet &type,
+  const source_locationt &location,
+  const irep_idt &mode,
+  symbol_table_baset &symtab);
+
 #endif // CPROVER_GOTO_INSTRUMENT_CONTRACTS_UTILS_H