Merge pull request #6989 from diffblue/remove_base_type

remove uses of base_type_eq

Author: kroening

src/analyses/does_remove_const.cpp

@@ -13,19 +13,13 @@ Author: Diffblue Ltd.
 
 #include <goto-programs/goto_program.h>
 
-#include <util/base_type.h>
 #include <util/pointer_expr.h>
 #include <util/std_code.h>
 
 /// A naive analysis to look for casts that remove const-ness from pointers.
 /// \param goto_program: the goto program to check
-/// \param ns: the namespace of the goto program (used for checking type
-///   equality)
-does_remove_constt::does_remove_constt(
-  const goto_programt &goto_program,
-  const namespacet &ns):
-    goto_program(goto_program),
-    ns(ns)
+does_remove_constt::does_remove_constt(const goto_programt &goto_program)
+  : goto_program(goto_program)
 {}
 
 /// A naive analysis to look for casts that remove const-ness from pointers.
@@ -69,11 +63,11 @@ bool does_remove_constt::does_expr_lose_const(const exprt &expr) const
 {
   const typet &root_type=expr.type();
 
-  // Look in each child that has the same base type as the root
+  // Look in each child that has the same type as the root
   for(const exprt &op : expr.operands())
   {
     const typet &op_type=op.type();
-    if(base_type_eq(op_type, root_type, ns))
+    if(op_type == root_type)
     {
       // Is this child more const-qualified than the root
       if(!does_type_preserve_const_correctness(&root_type, &op_type))

src/analyses/does_remove_const.h

@@ -14,15 +14,14 @@ Author: Diffblue Ltd.
 #include <utility>
 
 class goto_programt;
-class namespacet;
 class exprt;
 class source_locationt;
 class typet;
 
 class does_remove_constt
 {
 public:
-  does_remove_constt(const goto_programt &goto_program, const namespacet &ns);
+  explicit does_remove_constt(const goto_programt &);
   std::pair<bool, source_locationt>  operator()() const;
 
 private:
@@ -35,7 +34,6 @@ class does_remove_constt
     const typet *target_type, const typet *source_type) const;
 
   const goto_programt &goto_program;
-  const namespacet &ns;
 
   friend class does_remove_const_testt;
 };

src/goto-instrument/replace_calls.cpp

@@ -13,7 +13,6 @@ Author: Daniel Poetzl
 
 #include "replace_calls.h"
 
-#include <util/base_type.h>
 #include <util/exception_utils.h>
 #include <util/invariant.h>
 #include <util/namespace.h>
@@ -161,8 +160,7 @@ void replace_callst::check_replacement_map(
     auto it1 = goto_functions.function_map.find(p.first);
     if(it1 != goto_functions.function_map.end())
     {
-      if(!base_type_eq(
-           ns.lookup(it1->first).type, ns.lookup(it2->first).type, ns))
+      if(ns.lookup(it1->first).type != ns.lookup(it2->first).type)
         throw invalid_command_line_argument_exceptiont(
           "functions " + id2string(p.first) + " and " + id2string(p.second) +
             " are not type-compatible",

src/goto-programs/goto_program.cpp

@@ -15,7 +15,6 @@ Author: Daniel Kroening, [email protected]
 
 #include <iomanip>
 
-#include <util/base_type.h>
 #include <util/expr_iterator.h>
 #include <util/find_symbols.h>
 #include <util/format_expr.h>
@@ -808,7 +807,7 @@ void goto_programt::instructiont::validate(
         if(!ns.lookup(goto_id, table_symbol))
         {
           bool symbol_expr_type_matches_symbol_table =
-            base_type_eq(goto_symbol_expr.type(), table_symbol->type, ns);
+            goto_symbol_expr.type() == table_symbol->type;
 
           if(
             !symbol_expr_type_matches_symbol_table &&
@@ -831,7 +830,7 @@ void goto_programt::instructiont::validate(
                 table_symbol_type.return_type();
 
               symbol_expr_type_matches_symbol_table =
-                base_type_eq(goto_symbol_expr_type, table_symbol_type, ns);
+                goto_symbol_expr_type == table_symbol_type;
             }
           }
 

src/goto-programs/remove_function_pointers.cpp

@@ -270,7 +270,7 @@ void remove_function_pointerst::remove_function_pointer(
 
   const exprt &pointer = function.pointer();
   remove_const_function_pointerst::functionst functions;
-  does_remove_constt const_removal_check(goto_program, ns);
+  does_remove_constt const_removal_check(goto_program);
   const auto does_remove_const = const_removal_check();
   messaget log{message_handler};
   if(does_remove_const.first)

src/linking/linking.cpp

@@ -14,7 +14,6 @@ Author: Daniel Kroening, [email protected]
 #include <deque>
 #include <unordered_set>
 
-#include <util/base_type.h>
 #include <util/c_types.h>
 #include <util/find_symbols.h>
 #include <util/mathematical_types.h>
@@ -150,10 +149,8 @@ void linkingt::detailed_conflict_report_rec(
           t1.id()==ID_array)
   {
     if(
-      depth > 0 && !base_type_eq(
-                     to_type_with_subtype(t1).subtype(),
-                     to_type_with_subtype(t2).subtype(),
-                     ns))
+      depth > 0 &&
+      to_type_with_subtype(t1).subtype() != to_type_with_subtype(t2).subtype())
     {
       if(conflict_path.type().id() == ID_pointer)
         conflict_path = dereference_exprt(conflict_path);
@@ -202,7 +199,7 @@ void linkingt::detailed_conflict_report_rec(
           msg+=id2string(components2[i].get_name())+')';
           break;
         }
-        else if(!base_type_eq(subtype1, subtype2, ns))
+        else if(subtype1 != subtype2)
         {
           typedef std::unordered_set<typet, irep_hash> type_sett;
           type_sett parent_types;
@@ -332,7 +329,7 @@ void linkingt::detailed_conflict_report_rec(
       msg+=std::to_string(parameters1.size())+'/';
       msg+=std::to_string(parameters2.size())+')';
     }
-    else if(!base_type_eq(return_type1, return_type2, ns))
+    else if(return_type1 != return_type2)
     {
       conflict_path=
         index_exprt(conflict_path,
@@ -356,7 +353,7 @@ void linkingt::detailed_conflict_report_rec(
         const typet &subtype1=parameters1[i].type();
         const typet &subtype2=parameters2[i].type();
 
-        if(!base_type_eq(subtype1, subtype2, ns))
+        if(subtype1 != subtype2)
         {
           conflict_path=
             index_exprt(conflict_path,
@@ -475,7 +472,7 @@ void linkingt::duplicate_code_symbol(
   symbolt &new_symbol)
 {
   // Both are functions.
-  if(!base_type_eq(old_symbol.type, new_symbol.type, ns))
+  if(old_symbol.type != new_symbol.type)
   {
     const code_typet &old_t=to_code_type(old_symbol.type);
     const code_typet &new_t=to_code_type(new_symbol.type);
@@ -486,11 +483,8 @@ void linkingt::duplicate_code_symbol(
     // casts we need to fail hard
     if(old_symbol.type.get_bool(ID_C_incomplete) && old_symbol.value.is_nil())
     {
-      if(base_type_eq(old_t.return_type(), new_t.return_type(), ns))
-         link_warning(
-           old_symbol,
-           new_symbol,
-           "implicit function declaration");
+      if(old_t.return_type() == new_t.return_type())
+        link_warning(old_symbol, new_symbol, "implicit function declaration");
       else
         link_error(
           old_symbol,
@@ -504,7 +498,7 @@ void linkingt::duplicate_code_symbol(
     else if(
       new_symbol.type.get_bool(ID_C_incomplete) && new_symbol.value.is_nil())
     {
-      if(base_type_eq(old_t.return_type(), new_t.return_type(), ns))
+      if(old_t.return_type() == new_t.return_type())
         link_warning(
           old_symbol,
           new_symbol,
@@ -516,13 +510,12 @@ void linkingt::duplicate_code_symbol(
           "implicit function declaration");
     }
     // handle (incomplete) function prototypes
-    else if(base_type_eq(old_t.return_type(), new_t.return_type(), ns) &&
-            ((old_t.parameters().empty() &&
-              old_t.has_ellipsis() &&
-              old_symbol.value.is_nil()) ||
-             (new_t.parameters().empty() &&
-              new_t.has_ellipsis() &&
-              new_symbol.value.is_nil())))
+    else if(
+      old_t.return_type() == new_t.return_type() &&
+      ((old_t.parameters().empty() && old_t.has_ellipsis() &&
+        old_symbol.value.is_nil()) ||
+       (new_t.parameters().empty() && new_t.has_ellipsis() &&
+        new_symbol.value.is_nil())))
     {
       if(old_t.parameters().empty() &&
          old_t.has_ellipsis() &&
@@ -572,9 +565,9 @@ void linkingt::duplicate_code_symbol(
     }
     // conflicting declarations without a definition, matching return
     // types
-    else if(base_type_eq(old_t.return_type(), new_t.return_type(), ns) &&
-            old_symbol.value.is_nil() &&
-            new_symbol.value.is_nil())
+    else if(
+      old_t.return_type() == new_t.return_type() && old_symbol.value.is_nil() &&
+      new_symbol.value.is_nil())
     {
       link_warning(
         old_symbol,
@@ -613,7 +606,7 @@ void linkingt::duplicate_code_symbol(
       typedef std::deque<std::pair<typet, typet> > conflictst;
       conflictst conflicts;
 
-      if(!base_type_eq(old_t.return_type(), new_t.return_type(), ns))
+      if(old_t.return_type() != new_t.return_type())
         conflicts.push_back(
           std::make_pair(old_t.return_type(), new_t.return_type()));
 
@@ -625,7 +618,7 @@ void linkingt::duplicate_code_symbol(
           n_it!=new_t.parameters().end();
           ++o_it, ++n_it)
       {
-        if(!base_type_eq(o_it->type(), n_it->type(), ns))
+        if(o_it->type() != n_it->type())
           conflicts.push_back(
             std::make_pair(o_it->type(), n_it->type()));
       }
@@ -718,7 +711,7 @@ void linkingt::duplicate_code_symbol(
 
           bool found=false;
           for(const auto &c : union_type.components())
-            if(base_type_eq(c.type(), src_type, ns))
+            if(c.type() == src_type)
             {
               found=true;
               if(warn_msg.empty())
@@ -793,7 +786,7 @@ void linkingt::duplicate_code_symbol(
     {
       // ok, silently ignore
     }
-    else if(base_type_eq(old_symbol.type, new_symbol.type, ns))
+    else if(old_symbol.type == new_symbol.type)
     {
       // keep the one in old_symbol -- libraries come last!
       debug().source_location = new_symbol.location;
@@ -816,7 +809,7 @@ bool linkingt::adjust_object_type_rec(
   const typet &t2,
   adjust_type_infot &info)
 {
-  if(base_type_eq(t1, t2, ns))
+  if(t1 == t2)
     return false;
 
   if(
@@ -1025,7 +1018,7 @@ void linkingt::duplicate_object_symbol(
   // both are variables
   bool set_to_new = false;
 
-  if(!base_type_eq(old_symbol.type, new_symbol.type, ns))
+  if(old_symbol.type != new_symbol.type)
   {
     bool failed=
       adjust_object_type(old_symbol, new_symbol, set_to_new);
@@ -1081,7 +1074,7 @@ void linkingt::duplicate_object_symbol(
       simplify(tmp_old, ns);
       simplify(tmp_new, ns);
 
-      if(base_type_eq(tmp_old, tmp_new, ns))
+      if(tmp_old == tmp_new)
       {
         // ok, the same
       }
@@ -1211,10 +1204,8 @@ void linkingt::duplicate_type_symbol(
 
   if(
     old_symbol.type.id() == ID_array && new_symbol.type.id() == ID_array &&
-    base_type_eq(
-      to_array_type(old_symbol.type).element_type(),
-      to_array_type(new_symbol.type).element_type(),
-      ns))
+    to_array_type(old_symbol.type).element_type() ==
+      to_array_type(new_symbol.type).element_type())
   {
     if(to_array_type(old_symbol.type).size().is_nil() &&
        to_array_type(new_symbol.type).size().is_not_nil())
@@ -1286,10 +1277,8 @@ bool linkingt::needs_renaming_type(
 
   if(
     old_symbol.type.id() == ID_array && new_symbol.type.id() == ID_array &&
-    base_type_eq(
-      to_array_type(old_symbol.type).element_type(),
-      to_array_type(new_symbol.type).element_type(),
-      ns))
+    to_array_type(old_symbol.type).element_type() ==
+      to_array_type(new_symbol.type).element_type())
   {
     if(to_array_type(old_symbol.type).size().is_nil() &&
        to_array_type(new_symbol.type).size().is_not_nil())

src/util/Makefile

@@ -1,7 +1,6 @@
 SRC = arith_tools.cpp \
       array_element_from_pointer.cpp \
       array_name.cpp \
-      base_type.cpp \
       bitvector_expr.cpp \
       bitvector_types.cpp \
       bv_arithmetic.cpp \