Make renamedt inherit from underlyingt

This is so that we can easily convert from an exprt to a renamedt using
static_cast.
The potential use case, is to be able to look at all the operands of a
renamedt, as renamedt themselves without having to construct new
objects.
For instance assuming `f` takes `renamedt` as argument, we could declare
a renamedt method:
```
void renamedt::apply_to_operands()
{
  for(exprt &op : operands())
    f(static_cast<renamedt&>(op));
}
```

Author: romainbrenguier

src/goto-symex/goto_symex_state.cpp

@@ -261,12 +261,12 @@ goto_symex_statet::rename(exprt expr, const namespacet &ns)
     if(level == L0)
     {
       return renamedt<exprt, level>{
-        std::move(rename_ssa<L0>(std::move(ssa), ns).value)};
+        std::move(rename_ssa<L0>(std::move(ssa), ns).value())};
     }
     else if(level == L1)
     {
       return renamedt<exprt, level>{
-        std::move(rename_ssa<L1>(std::move(ssa), ns).value)};
+        std::move(rename_ssa<L1>(std::move(ssa), ns).value())};
     }
     else if(level==L2)
     {

src/goto-symex/renaming_level.cpp

@@ -50,27 +50,27 @@ operator()(renamedt<ssa_exprt, L0> l0_expr) const
     !l0_expr.get().get_level_1().empty() ||
     !l0_expr.get().get_level_2().empty())
   {
-    return renamedt<ssa_exprt, L1>{std::move(l0_expr.value)};
+    return renamedt<ssa_exprt, L1>{std::move(l0_expr.value())};
   }
 
   const irep_idt l0_name = l0_expr.get().get_l1_object_identifier();
 
   const auto it = current_names.find(l0_name);
   if(it == current_names.end())
-    return renamedt<ssa_exprt, L1>{std::move(l0_expr.value)};
+    return renamedt<ssa_exprt, L1>{std::move(l0_expr.value())};
 
   // rename!
-  l0_expr.value.set_level_1(it->second.second);
-  return renamedt<ssa_exprt, L1>{std::move(l0_expr.value)};
+  l0_expr.value().set_level_1(it->second.second);
+  return renamedt<ssa_exprt, L1>{std::move(l0_expr.value())};
 }
 
 renamedt<ssa_exprt, L2> symex_level2t::
 operator()(renamedt<ssa_exprt, L1> l1_expr) const
 {
   if(!l1_expr.get().get_level_2().empty())
-    return renamedt<ssa_exprt, L2>{std::move(l1_expr.value)};
-  l1_expr.value.set_level_2(current_count(l1_expr.get().get_identifier()));
-  return renamedt<ssa_exprt, L2>{std::move(l1_expr.value)};
+    return renamedt<ssa_exprt, L2>{std::move(l1_expr.value())};
+  l1_expr.value().set_level_2(current_count(l1_expr.get().get_identifier()));
+  return renamedt<ssa_exprt, L2>{std::move(l1_expr.value())};
 }
 
 void symex_level1t::restore_from(const current_namest &other)

src/goto-symex/renaming_level.h

@@ -69,7 +69,7 @@ struct symex_renaming_levelt
 /// Wrapper for expressions or types which have been renamed up to a given
 /// \p level
 template <typename underlyingt, levelt level>
-class renamedt
+class renamedt : private underlyingt
 {
 public:
   static_assert(
@@ -79,24 +79,27 @@ class renamedt
 
   const underlyingt &get() const
   {
-    return value;
+    return static_cast<const underlyingt &>(*this);
   }
 
   void simplify(const namespacet &ns)
   {
-    (void)::simplify(value, ns);
+    (void)::simplify(value(), ns);
   }
 
 private:
-  underlyingt value;
+  underlyingt &value()
+  {
+    return static_cast<underlyingt &>(*this);
+  };
 
   friend struct symex_level0t;
   friend struct symex_level1t;
   friend struct symex_level2t;
   friend class goto_symex_statet;
 
   /// Only the friend classes can create renamedt objects
-  explicit renamedt(underlyingt value) : value(std::move(value))
+  explicit renamedt(underlyingt value) : underlyingt(std::move(value))
   {
   }
 };