diff --git a/src/analyses/does_remove_const.cpp b/src/analyses/does_remove_const.cpp
index 6b620db9e89..69c988d7149 100644
--- a/src/analyses/does_remove_const.cpp
+++ b/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))
diff --git a/src/analyses/does_remove_const.h b/src/analyses/does_remove_const.h
index c213b09ec7e..b5a682aed2c 100644
--- a/src/analyses/does_remove_const.h
+++ b/src/analyses/does_remove_const.h
@@ -14,7 +14,6 @@ Author: Diffblue Ltd.
 #include <utility>
 
 class goto_programt;
-class namespacet;
 class exprt;
 class source_locationt;
 class typet;
@@ -22,7 +21,7 @@ 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;
 };
diff --git a/src/goto-instrument/replace_calls.cpp b/src/goto-instrument/replace_calls.cpp
index 8ea9706823a..bf7d64e8772 100644
--- a/src/goto-instrument/replace_calls.cpp
+++ b/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",
diff --git a/src/goto-programs/goto_program.cpp b/src/goto-programs/goto_program.cpp
index bbe246ab258..9e8d0e0bece 100644
--- a/src/goto-programs/goto_program.cpp
+++ b/src/goto-programs/goto_program.cpp
@@ -15,7 +15,6 @@ Author: Daniel Kroening, kroening@kroening.com
 
 #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;
             }
           }
 
diff --git a/src/goto-programs/remove_function_pointers.cpp b/src/goto-programs/remove_function_pointers.cpp
index 5d1f373ec57..4a4d9d6c129 100644
--- a/src/goto-programs/remove_function_pointers.cpp
+++ b/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)
diff --git a/src/linking/linking.cpp b/src/linking/linking.cpp
index b9afdff9008..60f41318745 100644
--- a/src/linking/linking.cpp
+++ b/src/linking/linking.cpp
@@ -14,7 +14,6 @@ Author: Daniel Kroening, kroening@kroening.com
 #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())
diff --git a/src/util/Makefile b/src/util/Makefile
index fc441dc79d0..431cdb15f0d 100644
--- a/src/util/Makefile
+++ b/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 \
diff --git a/src/util/base_type.cpp b/src/util/base_type.cpp
deleted file mode 100644
index 57749bd396c..00000000000
--- a/src/util/base_type.cpp
+++ /dev/null
@@ -1,311 +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 "pointer_expr.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).element_type(), 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 &base_type = to_pointer_type(type).base_type();
-
-    // we need to avoid running into an infinite loop
-    if(
-      base_type.id() == ID_c_enum_tag || base_type.id() == ID_struct_tag ||
-      base_type.id() == ID_union_tag)
-    {
-      const irep_idt &id = to_tag_type(base_type).get_identifier();
-
-      if(symb.find(id)!=symb.end())
-        return;
-
-      symb.insert(id);
-
-      base_type_rec(base_type, ns, symb);
-
-      symb.erase(id);
-    }
-    else
-      base_type_rec(base_type, 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).base_type(), to_pointer_type(type2).base_type());
-  }
-  else if(type1.id()==ID_array)
-  {
-    if(!base_type_eq_rec(
-         to_array_type(type1).element_type(),
-         to_array_type(type2).element_type()))
-      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
diff --git a/unit/analyses/does_remove_const/does_expr_lose_const.cpp b/unit/analyses/does_remove_const/does_expr_lose_const.cpp
index d1a41bdf867..c42004822b6 100644
--- a/unit/analyses/does_remove_const/does_expr_lose_const.cpp
+++ b/unit/analyses/does_remove_const/does_expr_lose_const.cpp
@@ -30,7 +30,7 @@ SCENARIO("does_expr_lose_const",
   symbol_tablet symbol_table;
   namespacet ns(symbol_table);
   goto_programt program;
-  does_remove_constt does_remove_const(program, ns);
+  does_remove_constt does_remove_const(program);
   does_remove_const_testt does_remove_const_test(does_remove_const);
 
   GIVEN("Const and non-const primitive and pointers to primitives")
diff --git a/unit/analyses/does_remove_const/does_type_preserve_const_correctness.cpp b/unit/analyses/does_remove_const/does_type_preserve_const_correctness.cpp
index 0e00f81fa6b..6dde902a93d 100644
--- a/unit/analyses/does_remove_const/does_type_preserve_const_correctness.cpp
+++ b/unit/analyses/does_remove_const/does_type_preserve_const_correctness.cpp
@@ -29,7 +29,7 @@ SCENARIO("does_type_preserve_const_correctness",
   symbol_tablet symbol_table;
   namespacet ns(symbol_table);
   goto_programt program;
-  does_remove_constt does_remove_const(program, ns);
+  does_remove_constt does_remove_const(program);
   does_remove_const_testt does_remove_const_test(does_remove_const);
 
   GIVEN("Const and non-const primitive and pointers to primitives")
diff --git a/unit/analyses/does_remove_const/is_type_at_least_as_const_as.cpp b/unit/analyses/does_remove_const/is_type_at_least_as_const_as.cpp
index d9a91b94096..0771edf69e9 100644
--- a/unit/analyses/does_remove_const/is_type_at_least_as_const_as.cpp
+++ b/unit/analyses/does_remove_const/is_type_at_least_as_const_as.cpp
@@ -29,7 +29,7 @@ SCENARIO("is_type_at_least_as_const",
   symbol_tablet symbol_table;
   namespacet ns(symbol_table);
   goto_programt program;
-  does_remove_constt does_remove_const(program, ns);
+  does_remove_constt does_remove_const(program);
   does_remove_const_testt does_remove_const_test(does_remove_const);
 
   GIVEN("Const and non-const primitive and pointers to primitives")