Remove type_eq

With the earlier removal of symbol_type its functionality is exactly the same as
directly using operator== on types.

Author: Daniel Kroening

src/goto-instrument/goto_program2code.cpp

@@ -20,7 +20,6 @@ Author: Daniel Kroening, [email protected]
 #include <util/find_symbols.h>
 #include <util/prefix.h>
 #include <util/simplify_expr.h>
-#include <util/type_eq.h>
 
 void goto_program2codet::operator()()
 {
@@ -1876,7 +1875,7 @@ void goto_program2codet::cleanup_expr(exprt &expr, bool no_typecast)
         if(!has_prefix(id2string(it->second.base_name), "nondet_"))
           continue;
         const code_typet &code_type=to_code_type(it->second.type);
-        if(!type_eq(code_type.return_type(), expr.type(), ns))
+        if(code_type.return_type() != expr.type())
           continue;
         if(!code_type.parameters().empty())
           continue;

src/goto-programs/remove_function_pointers.cpp

@@ -22,7 +22,6 @@ Author: Daniel Kroening, [email protected]
 #include <util/replace_expr.h>
 #include <util/source_location.h>
 #include <util/std_expr.h>
-#include <util/type_eq.h>
 
 #include <analyses/does_remove_const.h>
 
@@ -134,7 +133,7 @@ bool remove_function_pointerst::arg_is_type_compatible(
   const typet &call_type,
   const typet &function_type)
 {
-  if(type_eq(call_type, function_type, ns))
+  if(call_type == function_type)
     return true;
 
   // any integer-vs-enum-vs-pointer is ok
@@ -166,7 +165,7 @@ bool remove_function_pointerst::is_type_compatible(
   if(!return_value_used)
   {
   }
-  else if(type_eq(call_type.return_type(), empty_typet(), ns))
+  else if(call_type.return_type() == empty_typet())
   {
     // ok
   }
@@ -221,8 +220,7 @@ void remove_function_pointerst::fix_argument_types(
   {
     if(i<call_arguments.size())
     {
-      if(!type_eq(call_arguments[i].type(),
-                  function_parameters[i].type(), ns))
+      if(call_arguments[i].type() != function_parameters[i].type())
       {
         call_arguments[i] =
           typecast_exprt(call_arguments[i], function_parameters[i].type());
@@ -243,9 +241,7 @@ void remove_function_pointerst::fix_return_type(
   const code_typet &code_type = to_code_type(function_call.function().type());
 
   // type already ok?
-  if(type_eq(
-       function_call.lhs().type(),
-       code_type.return_type(), ns))
+  if(function_call.lhs().type() == code_type.return_type())
     return;
 
   const symbolt &function_symbol =

src/goto-programs/remove_virtual_functions.cpp

@@ -13,7 +13,6 @@ Author: Daniel Kroening, [email protected]
 #include <algorithm>
 
 #include <util/prefix.h>
-#include <util/type_eq.h>
 
 #include "class_identifier.h"
 #include "goto_model.h"
@@ -131,7 +130,7 @@ static void create_static_function_call(
   {
     const typet &need_type = callee_parameters[i].type();
 
-    if(!type_eq(call_args[i].type(), need_type, ns))
+    if(call_args[i].type() != need_type)
     {
       // If this wasn't language agnostic code we'd also like to check
       // compatibility-- for example, Java overrides may have differing generic

src/goto-programs/string_abstraction.cpp

@@ -19,7 +19,6 @@ Author: Daniel Kroening, [email protected]
 #include <util/expr_util.h>
 #include <util/pointer_predicates.h>
 #include <util/string_constant.h>
-#include <util/type_eq.h>
 
 #include "pointer_arithmetic.h"
 
@@ -36,13 +35,14 @@ bool string_abstractiont::build_wrap(
   // #define build_wrap(a,b,c) build(a,b,c)
   // to avoid it
   const typet &a_t=build_abstraction_type(object.type());
-  /*assert(type_eq(dest.type(), a_t, ns) ||
+  /*assert(dest.type() == a_t ||
       (dest.type().id()==ID_array && a_t.id()==ID_pointer &&
-       type_eq(dest.type().subtype(), a_t.subtype(), ns)));
+       dest.type().subtype() == a_t.subtype()));
        */
-  if(!type_eq(dest.type(), a_t, ns) &&
-      !(dest.type().id()==ID_array && a_t.id()==ID_pointer &&
-       type_eq(dest.type().subtype(), a_t.subtype(), ns)))
+  if(
+    dest.type() != a_t &&
+    !(dest.type().id() == ID_array && a_t.id() == ID_pointer &&
+      dest.type().subtype() == a_t.subtype()))
   {
     warning() << "warning: inconsistent abstract type for "
               << object.pretty() << eom;
@@ -54,8 +54,7 @@ bool string_abstractiont::build_wrap(
 
 bool string_abstractiont::is_ptr_string_struct(const typet &type) const
 {
-  return type.id()==ID_pointer &&
-    type_eq(type.subtype(), string_struct, ns);
+  return type.id() == ID_pointer && type.subtype() == string_struct;
 }
 
 static inline bool is_ptr_argument(const typet &type)
@@ -323,8 +322,9 @@ exprt string_abstractiont::make_val_or_dummy_rec(goto_programt &dest,
     else
       return address_of_exprt(sym_expr);
   }
-  else if(eff_type.id()==ID_union ||
-      (eff_type.id()==ID_struct && !type_eq(eff_type, string_struct, ns)))
+  else if(
+    eff_type.id() == ID_union ||
+    (eff_type.id() == ID_struct && eff_type != string_struct))
   {
     const struct_union_typet &su_source=to_struct_union_type(source_type);
     const struct_union_typet::componentst &s_components=
@@ -406,8 +406,9 @@ symbol_exprt string_abstractiont::add_dummy_symbol_and_value(
   decl->code.add_source_location()=ref_instr->source_location;
 
   // set the value - may be nil
-  if(source_type.id()==ID_array && is_char_type(source_type.subtype()) &&
-      type_eq(type, string_struct, ns))
+  if(
+    source_type.id() == ID_array && is_char_type(source_type.subtype()) &&
+    type == string_struct)
   {
     new_symbol.value = struct_exprt(
       {build_unknown(whatt::IS_ZERO, false),
@@ -553,7 +554,7 @@ void string_abstractiont::abstract_function_call(
         abstract_type.id()==ID_pointer)
     {
       INVARIANT(
-        type_eq(str_args.back().type().subtype(), abstract_type.subtype(), ns),
+        str_args.back().type().subtype() == abstract_type.subtype(),
         "argument array type differs from formal parameter pointer type");
 
       index_exprt idx(str_args.back(), from_integer(0, index_type()));
@@ -743,10 +744,9 @@ bool string_abstractiont::build(const exprt &object, exprt &dest, bool write)
     if(build(to_typecast_expr(object).op(), dest, write))
       return true;
 
-    return !(type_eq(dest.type(), abstract_type, ns) ||
-        (dest.type().id()==ID_array &&
-         abstract_type.id()==ID_pointer &&
-         type_eq(dest.type().subtype(), abstract_type.subtype(), ns)));
+    return dest.type() != abstract_type ||
+           (dest.type().id() == ID_array && abstract_type.id() == ID_pointer &&
+            dest.type().subtype() == abstract_type.subtype());
   }
 
   if(object.id()==ID_string_constant)
@@ -1200,7 +1200,7 @@ goto_programt::targett string_abstractiont::value_assignments(
   if(rhs.id()==ID_if)
     return value_assignments_if(dest, target, lhs, to_if_expr(rhs));
 
-  PRECONDITION(type_eq(lhs.type(), rhs.type(), ns));
+  PRECONDITION(lhs.type() == rhs.type());
 
   if(lhs.type().id()==ID_array)
   {
@@ -1318,7 +1318,7 @@ exprt string_abstractiont::member(const exprt &a, whatt what)
     return a;
 
   PRECONDITION_WITH_DIAGNOSTICS(
-    type_eq(a.type(), string_struct, ns) || is_ptr_string_struct(a.type()),
+    a.type() == string_struct || is_ptr_string_struct(a.type()),
     "either the expression is not a string or it is not a pointer to one");
 
   exprt struct_op=

src/util/Makefile

@@ -91,7 +91,6 @@ SRC = allocate_objects.cpp \
       threeval.cpp \
       timestamper.cpp \
       type.cpp \
-      type_eq.cpp \
       typecheck.cpp \
       ui_message.cpp \
       unicode.cpp \

src/util/allocate_objects.cpp

@@ -13,7 +13,6 @@ Author: Daniel Kroening, [email protected]
 #include "fresh_symbol.h"
 #include "pointer_offset_size.h"
 #include "string_constant.h"
-#include "type_eq.h"
 
 /// Allocates a new object, either by creating a local variable with automatic
 /// lifetime, a global variable with static lifetime, or by dynamically
@@ -183,10 +182,8 @@ exprt allocate_objectst::allocate_dynamic_object(
   assign.add_source_location() = source_location;
   output_code.add(assign);
 
-  exprt malloc_symbol_expr =
-    !type_eq(malloc_sym.symbol_expr().type(), target_expr.type(), ns)
-      ? (exprt)typecast_exprt(malloc_sym.symbol_expr(), target_expr.type())
-      : malloc_sym.symbol_expr();
+  exprt malloc_symbol_expr = typecast_exprt::conditional_cast(
+    malloc_sym.symbol_expr(), target_expr.type());
 
   code_assignt code(target_expr, malloc_symbol_expr);
   code.add_source_location() = source_location;

src/util/simplify_expr.cpp

@@ -29,7 +29,6 @@ Author: Daniel Kroening, [email protected]
 #include "string_constant.h"
 #include "string_expr.h"
 #include "symbol.h"
-#include "type_eq.h"
 
 // #define DEBUGX
 
@@ -317,7 +316,7 @@ bool simplify_exprt::simplify_typecast(exprt &expr)
   }
 
   // eliminate redundant typecasts
-  if(type_eq(expr.type(), expr.op0().type(), ns))
+  if(expr.type() == expr.op0().type())
   {
     exprt tmp;
     tmp.swap(expr.op0());

src/util/simplify_expr_struct.cpp

@@ -15,7 +15,6 @@ Author: Daniel Kroening, [email protected]
 #include "namespace.h"
 #include "pointer_offset_size.h"
 #include "std_expr.h"
-#include "type_eq.h"
 
 bool simplify_exprt::simplify_member(exprt &expr)
 {
@@ -207,7 +206,7 @@ bool simplify_exprt::simplify_member(exprt &expr)
   else if(op.id()==ID_union && op_type.id()==ID_union)
   {
     // trivial?
-    if(type_eq(to_union_expr(op).op().type(), expr.type(), ns))
+    if(to_union_expr(op).op().type() == expr.type())
     {
       exprt tmp=to_union_expr(op).op();
       expr.swap(tmp);
@@ -271,7 +270,7 @@ bool simplify_exprt::simplify_member(exprt &expr)
           equivalent_member.has_value() &&
           equivalent_member.value().id() != ID_byte_extract_little_endian &&
           equivalent_member.value().id() != ID_byte_extract_big_endian &&
-          type_eq(equivalent_member.value().type(), expr.type(), ns))
+          equivalent_member.value().type() == expr.type())
         {
           expr = equivalent_member.value();
           simplify_rec(expr);