diff --git a/src/analyses/does_remove_const.cpp b/src/analyses/does_remove_const.cpp
index 265cdda8936..443c3e52c57 100644
--- a/src/analyses/does_remove_const.cpp
+++ b/src/analyses/does_remove_const.cpp
@@ -15,7 +15,6 @@ Author: Diffblue Ltd.
 #include <util/type.h>
 #include <util/expr.h>
 #include <util/std_code.h>
-#include <util/base_type.h>
 
 /// A naive analysis to look for casts that remove const-ness from pointers.
 /// \param goto_program: the goto program to check
@@ -74,7 +73,7 @@ bool does_remove_constt::does_expr_lose_const(const exprt &expr) const
   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))
diff --git a/src/goto-programs/goto_program.cpp b/src/goto-programs/goto_program.cpp
index b1237001e5c..397e30153c8 100644
--- a/src/goto-programs/goto_program.cpp
+++ b/src/goto-programs/goto_program.cpp
@@ -14,7 +14,6 @@ Author: Daniel Kroening, kroening@kroening.com
 #include <ostream>
 #include <iomanip>
 
-#include <util/base_type.h>
 #include <util/expr_iterator.h>
 #include <util/find_symbols.h>
 #include <util/invariant.h>
@@ -740,7 +739,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 &&
@@ -763,7 +762,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;
             }
           }
 
diff --git a/src/goto-programs/link_goto_model.cpp b/src/goto-programs/link_goto_model.cpp
index 9d17a208287..395f4518daa 100644
--- a/src/goto-programs/link_goto_model.cpp
+++ b/src/goto-programs/link_goto_model.cpp
@@ -13,7 +13,6 @@ Author: Michael Tautschnig, Daniel Kroening
 
 #include <unordered_set>
 
-#include <util/base_type.h>
 #include <util/symbol.h>
 #include <util/rename_symbol.h>
 
@@ -114,8 +113,9 @@ static bool link_functions(
       {
         // the linking code will have ensured that types match
         rename_symbol(src_func.type);
-        INVARIANT(base_type_eq(in_dest_symbol_table.type, src_func.type, ns),
-                  "linking ensures that types match");
+        INVARIANT(
+          in_dest_symbol_table.type == src_func.type,
+          "linking ensures that types match");
       }
     }
   }
diff --git a/src/goto-programs/replace_calls.cpp b/src/goto-programs/replace_calls.cpp
index bcda1f462e9..15b4e09d878 100644
--- a/src/goto-programs/replace_calls.cpp
+++ b/src/goto-programs/replace_calls.cpp
@@ -15,7 +15,6 @@ Author: Daniel Poetzl
 
 #include <goto-programs/remove_returns.h>
 
-#include <util/base_type.h>
 #include <util/exception_utils.h>
 #include <util/invariant.h>
 #include <util/irep.h>
@@ -94,7 +93,7 @@ void replace_callst::operator()(
     auto f_it2 = goto_functions.function_map.find(new_id);
     PRECONDITION(f_it2 != goto_functions.function_map.end());
 
-    PRECONDITION(base_type_eq(f_it1->second.type, f_it2->second.type, ns));
+    PRECONDITION(f_it1->second.type == f_it2->second.type);
 
     // check that returns have not been removed
     if(to_code_type(f_it1->second.type).return_type().id() != ID_empty)
@@ -167,7 +166,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(it1->second.type, it2->second.type, ns))
+      if(it1->second.type != it2->second.type)
         throw invalid_command_line_argument_exceptiont(
           "functions " + id2string(p.first) + " and " + id2string(p.second) +
             " are not type-compatible",
diff --git a/src/linking/linking.cpp b/src/linking/linking.cpp
index a622fd6167e..bb4ad702f44 100644
--- a/src/linking/linking.cpp
+++ b/src/linking/linking.cpp
@@ -15,7 +15,6 @@ Author: Daniel Kroening, kroening@kroening.com
 #include <deque>
 #include <unordered_set>
 
-#include <util/base_type.h>
 #include <util/find_symbols.h>
 #include <util/mathematical_types.h>
 #include <util/pointer_offset_size.h>
@@ -140,8 +139,7 @@ void linkingt::detailed_conflict_report_rec(
   else if(t1.id()==ID_pointer ||
           t1.id()==ID_array)
   {
-    if(depth>0 &&
-       !base_type_eq(t1.subtype(), t2.subtype(), ns))
+    if(depth > 0 && t1.subtype() != t2.subtype())
     {
       if(conflict_path.type().id() == ID_pointer)
         conflict_path = dereference_exprt(conflict_path);
@@ -190,7 +188,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;
@@ -307,7 +305,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,
@@ -331,7 +329,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,
@@ -450,7 +448,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);
@@ -461,11 +459,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,
@@ -479,7 +474,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,
@@ -491,13 +486,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() &&
@@ -547,9 +541,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,
@@ -588,7 +582,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()));
 
@@ -600,7 +594,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()));
       }
@@ -693,7 +687,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())
@@ -768,7 +762,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!
       warning().source_location=new_symbol.location;
@@ -791,7 +785,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(
@@ -987,7 +981,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);
@@ -1045,7 +1039,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
       }
@@ -1170,9 +1164,9 @@ void linkingt::duplicate_type_symbol(
     return;
   }
 
-  if(old_symbol.type.id()==ID_array &&
-     new_symbol.type.id()==ID_array &&
-     base_type_eq(old_symbol.type.subtype(), new_symbol.type.subtype(), ns))
+  if(
+    old_symbol.type.id() == ID_array && new_symbol.type.id() == ID_array &&
+    old_symbol.type.subtype() == new_symbol.type.subtype())
   {
     if(to_array_type(old_symbol.type).size().is_nil() &&
        to_array_type(new_symbol.type).size().is_not_nil())
@@ -1242,9 +1236,9 @@ bool linkingt::needs_renaming_type(
     to_union_type(new_symbol.type).is_incomplete())
     return false; // not different
 
-  if(old_symbol.type.id()==ID_array &&
-     new_symbol.type.id()==ID_array &&
-     base_type_eq(old_symbol.type.subtype(), new_symbol.type.subtype(), ns))
+  if(
+    old_symbol.type.id() == ID_array && new_symbol.type.id() == ID_array &&
+    old_symbol.type.subtype() == new_symbol.type.subtype())
   {
     if(to_array_type(old_symbol.type).size().is_nil() &&
        to_array_type(new_symbol.type).size().is_not_nil())
diff --git a/src/util/Makefile b/src/util/Makefile
index 2f3eda6a6b0..aa91e3865f7 100644
--- a/src/util/Makefile
+++ b/src/util/Makefile
@@ -2,7 +2,6 @@ SRC = allocate_objects.cpp \
       arith_tools.cpp \
       array_element_from_pointer.cpp \
       array_name.cpp \
-      base_type.cpp \
       bv_arithmetic.cpp \
       byte_operators.cpp \
       c_types.cpp \
diff --git a/src/util/base_type.cpp b/src/util/base_type.cpp
deleted file mode 100644
index f352a834dbd..00000000000
--- a/src/util/base_type.cpp
+++ /dev/null
@@ -1,310 +0,0 @@
-/*******************************************************************\
-
-Module: Base Type Computation
-
-Author: Daniel Kroening, kroening@kroening.com
-
-\*******************************************************************/
-
-/// \file
-/// Base Type Computation
-
-#include "base_type.h"
-
-#include <set>
-
-#include "namespace.h"
-#include "std_types.h"
-#include "symbol.h"
-#include "union_find.h"
-
-class base_type_eqt
-{
-public:
-  explicit base_type_eqt(const namespacet &_ns):ns(_ns)
-  {
-  }
-
-  bool base_type_eq(const typet &type1, const typet &type2)
-  {
-    identifiers.clear();
-    return base_type_eq_rec(type1, type2);
-  }
-
-  bool base_type_eq(const exprt &expr1, const exprt &expr2)
-  {
-    identifiers.clear();
-    return base_type_eq_rec(expr1, expr2);
-  }
-
-  virtual ~base_type_eqt() { }
-
-protected:
-  const namespacet &ns;
-
-  virtual bool base_type_eq_rec(const typet &type1, const typet &type2);
-  virtual bool base_type_eq_rec(const exprt &expr1, const exprt &expr2);
-
-  // for loop avoidance
-  typedef union_find<irep_idt> identifierst;
-  identifierst identifiers;
-};
-
-void base_type_rec(
-  typet &type, const namespacet &ns, std::set<irep_idt> &symb)
-{
-  if(
-    type.id() == ID_c_enum_tag || type.id() == ID_struct_tag ||
-    type.id() == ID_union_tag)
-  {
-    const symbolt *symbol;
-
-    if(
-      !ns.lookup(to_tag_type(type).get_identifier(), symbol) &&
-      symbol->is_type && !symbol->type.is_nil())
-    {
-      type=symbol->type;
-      base_type_rec(type, ns, symb); // recursive call
-      return;
-    }
-  }
-  else if(type.id()==ID_array)
-  {
-    base_type_rec(to_array_type(type).subtype(), ns, symb);
-  }
-  else if(type.id()==ID_struct ||
-          type.id()==ID_union)
-  {
-    struct_union_typet::componentst &components=
-      to_struct_union_type(type).components();
-
-    for(auto &component : components)
-      base_type_rec(component.type(), ns, symb);
-  }
-  else if(type.id()==ID_pointer)
-  {
-    typet &subtype=to_pointer_type(type).subtype();
-
-    // we need to avoid running into an infinite loop
-    if(
-      subtype.id() == ID_c_enum_tag || subtype.id() == ID_struct_tag ||
-      subtype.id() == ID_union_tag)
-    {
-      const irep_idt &id = to_tag_type(subtype).get_identifier();
-
-      if(symb.find(id)!=symb.end())
-        return;
-
-      symb.insert(id);
-
-      base_type_rec(subtype, ns, symb);
-
-      symb.erase(id);
-    }
-    else
-      base_type_rec(subtype, ns, symb);
-  }
-}
-
-void base_type(typet &type, const namespacet &ns)
-{
-  std::set<irep_idt> symb;
-  base_type_rec(type, ns, symb);
-}
-
-void base_type(exprt &expr, const namespacet &ns)
-{
-  base_type(expr.type(), ns);
-
-  Forall_operands(it, expr)
-    base_type(*it, ns);
-}
-
-bool base_type_eqt::base_type_eq_rec(
-  const typet &type1,
-  const typet &type2)
-{
-  if(type1==type2)
-    return true;
-
-  #if 0
-  std::cout << "T1: " << type1.pretty() << '\n';
-  std::cout << "T2: " << type2.pretty() << '\n';
-  #endif
-
-  // loop avoidance
-  if(
-    (type1.id() == ID_c_enum_tag || type1.id() == ID_struct_tag ||
-     type1.id() == ID_union_tag) &&
-    type2.id() == type1.id())
-  {
-    // already in same set?
-    if(identifiers.make_union(
-         type1.get(ID_identifier),
-         type2.get(ID_identifier)))
-      return true;
-  }
-
-  if(
-    type1.id() == ID_c_enum_tag || type1.id() == ID_struct_tag ||
-    type1.id() == ID_union_tag)
-  {
-    const symbolt &symbol=
-      ns.lookup(type1.get(ID_identifier));
-
-    if(!symbol.is_type)
-      return false;
-
-    return base_type_eq_rec(symbol.type, type2);
-  }
-
-  if(
-    type2.id() == ID_c_enum_tag || type2.id() == ID_struct_tag ||
-    type2.id() == ID_union_tag)
-  {
-    const symbolt &symbol=
-      ns.lookup(type2.get(ID_identifier));
-
-    if(!symbol.is_type)
-      return false;
-
-    return base_type_eq_rec(type1, symbol.type);
-  }
-
-  if(type1.id()!=type2.id())
-    return false;
-
-  if(type1.id()==ID_struct ||
-     type1.id()==ID_union)
-  {
-    const struct_union_typet::componentst &components1=
-      to_struct_union_type(type1).components();
-
-    const struct_union_typet::componentst &components2=
-      to_struct_union_type(type2).components();
-
-    if(components1.size()!=components2.size())
-      return false;
-
-    for(std::size_t i=0; i<components1.size(); i++)
-    {
-      const typet &subtype1=components1[i].type();
-      const typet &subtype2=components2[i].type();
-      if(!base_type_eq_rec(subtype1, subtype2))
-        return false;
-      if(components1[i].get_name()!=components2[i].get_name())
-        return false;
-    }
-
-    return true;
-  }
-  else if(type1.id()==ID_code)
-  {
-    const code_typet::parameterst &parameters1=
-      to_code_type(type1).parameters();
-
-    const code_typet::parameterst &parameters2=
-      to_code_type(type2).parameters();
-
-    if(parameters1.size()!=parameters2.size())
-      return false;
-
-    for(std::size_t i=0; i<parameters1.size(); i++)
-    {
-      const typet &subtype1=parameters1[i].type();
-      const typet &subtype2=parameters2[i].type();
-      if(!base_type_eq_rec(subtype1, subtype2))
-        return false;
-    }
-
-    const typet &return_type1=to_code_type(type1).return_type();
-    const typet &return_type2=to_code_type(type2).return_type();
-
-    if(!base_type_eq_rec(return_type1, return_type2))
-      return false;
-
-    return true;
-  }
-  else if(type1.id()==ID_pointer)
-  {
-    return base_type_eq_rec(
-      to_pointer_type(type1).subtype(), to_pointer_type(type2).subtype());
-  }
-  else if(type1.id()==ID_array)
-  {
-    if(!base_type_eq_rec(
-      to_array_type(type1).subtype(), to_array_type(type2).subtype()))
-      return false;
-
-    if(to_array_type(type1).size()!=to_array_type(type2).size())
-      return false;
-
-    return true;
-  }
-
-  // the below will go away
-  typet tmp1(type1), tmp2(type2);
-
-  base_type(tmp1, ns);
-  base_type(tmp2, ns);
-
-  return tmp1==tmp2;
-}
-
-bool base_type_eqt::base_type_eq_rec(
-  const exprt &expr1,
-  const exprt &expr2)
-{
-  if(expr1.id()!=expr2.id())
-    return false;
-
-  if(!base_type_eq(expr1.type(), expr2.type()))
-    return false;
-
-  const exprt::operandst &expr1_op=expr1.operands();
-  const exprt::operandst &expr2_op=expr2.operands();
-  if(expr1_op.size()!=expr2_op.size())
-    return false;
-
-  for(exprt::operandst::const_iterator
-      it1=expr1_op.begin(), it2=expr2_op.begin();
-      it1!=expr1_op.end() && it2!=expr2_op.end();
-      ++it1, ++it2)
-    if(!base_type_eq(*it1, *it2))
-      return false;
-
-  if(expr1.id()==ID_constant)
-    if(expr1.get(ID_value)!=expr2.get(ID_value))
-      return false;
-
-  return true;
-}
-
-/// Check types for equality across all levels of hierarchy.
-/// Example:
-/// - `struct_typet {union_tag_typet("a")}` and `struct_typet {ns.lookup("a")
-///   .type}` will compare equal.
-/// \param type1: The first type to compare.
-/// \param type2: The second type to compare.
-/// \param ns: The namespace, needed for resolution of symbols.
-bool base_type_eq(
-  const typet &type1,
-  const typet &type2,
-  const namespacet &ns)
-{
-  base_type_eqt base_type_eq(ns);
-  return base_type_eq.base_type_eq(type1, type2);
-}
-
-/// Check expressions for equality across all levels of hierarchy.
-/// \param expr1: The first expression to compare.
-/// \param expr2: The second expression to compare.
-/// \param ns: The namespace, needed for resolution of symbols.
-bool base_type_eq(
-  const exprt &expr1,
-  const exprt &expr2,
-  const namespacet &ns)
-{
-  base_type_eqt base_type_eq(ns);
-  return base_type_eq.base_type_eq(expr1, expr2);
-}
diff --git a/src/util/base_type.h b/src/util/base_type.h
deleted file mode 100644
index 6e6fe4d2088..00000000000
--- a/src/util/base_type.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*******************************************************************\
-
-Module: Base Type Computation
-
-Author: Daniel Kroening, kroening@kroening.com
-
-\*******************************************************************/
-
-/// \file
-/// Base Type Computation
-
-#ifndef CPROVER_UTIL_BASE_TYPE_H
-#define CPROVER_UTIL_BASE_TYPE_H
-
-#include "deprecate.h"
-
-class exprt;
-class typet;
-class namespacet;
-
-DEPRECATED(SINCE(2019, 1, 22, "Use == instead"))
-bool base_type_eq(
-  const typet &type1,
-  const typet &type2,
-  const namespacet &ns);
-
-DEPRECATED(SINCE(2019, 1, 22, "Use == instead"))
-bool base_type_eq(
-  const exprt &expr1,
-  const exprt &expr2,
-  const namespacet &ns);
-
-#endif // CPROVER_UTIL_BASE_TYPE_H