introduce protected_exprt

This will serve as the interface that we aspire exprt to offer; in
particular, access to opX is protected.

Author: Daniel Kroening

src/ansi-c/expr2c.cpp

@@ -1939,9 +1939,11 @@ std::string expr2ct::convert_constant(
       if(src.operands().size()!=1)
         return convert_norep(src, precedence);
 
-      if(src.op0().id()==ID_constant)
+      const auto &annotation = to_unary_expr(src).op();
+
+      if(annotation.id() == ID_constant)
       {
-        const irep_idt &op_value=src.op0().get(ID_value);
+        const irep_idt &op_value = to_constant_expr(annotation).get_value();
 
         if(op_value=="INVALID" ||
            has_prefix(id2string(op_value), "INVALID-") ||
@@ -1951,7 +1953,7 @@ std::string expr2ct::convert_constant(
           return convert_norep(src, precedence);
       }
       else
-        return convert_with_precedence(src.op0(), precedence);
+        return convert_with_precedence(annotation, precedence);
     }
   }
   else if(type.id()==ID_string)

src/goto-programs/remove_function_pointers.cpp

@@ -391,13 +391,13 @@ void remove_function_pointerst::remove_function_pointer(
     t3->make_goto(t_final, true_exprt());
 
     // goto to call
-    address_of_exprt address_of(fun, pointer_type(fun.type()));
+    const address_of_exprt address_of(fun, pointer_type(fun.type()));
 
-    if(address_of.type()!=pointer.type())
-      address_of.make_typecast(pointer.type());
+    const auto casted_address =
+      typecast_exprt::conditional_cast(address_of, pointer.type());
 
     goto_programt::targett t4=new_code_gotos.add_instruction();
-    t4->make_goto(t1, equal_exprt(pointer, address_of));
+    t4->make_goto(t1, equal_exprt(pointer, casted_address));
   }
 
   // fall-through

src/pointer-analysis/value_set_fi.cpp

@@ -850,8 +850,8 @@ void value_set_fit::get_reference_set_sharing_rec(
         insert(dest, exprt(ID_unknown, expr.type()));
       else
       {
-        index_exprt index_expr(
-          object, from_integer(0, index_type()), expr.type());
+        exprt index_expr =
+          index_exprt(object, from_integer(0, index_type()), expr.type());
 
         // adjust type?
         if(object.type().id() != "#REF#" && object.type() != array_type)

src/pointer-analysis/value_set_fivr.cpp

@@ -961,8 +961,8 @@ void value_set_fivrt::get_reference_set_sharing_rec(
         insert_from(dest, exprt(ID_unknown, expr.type()));
       else
       {
-        index_exprt index_expr(
-          object, from_integer(0, index_type()), expr.type());
+        exprt index_expr =
+          index_exprt(object, from_integer(0, index_type()), expr.type());
 
         // adjust type?
         if(object.type().id() != "#REF#" && object.type() != array_type)

src/pointer-analysis/value_set_fivrns.cpp

@@ -654,8 +654,8 @@ void value_set_fivrnst::get_reference_set_rec(
         insert_from(dest, exprt(ID_unknown, expr.type()));
       else
       {
-        index_exprt index_expr(
-          object, from_integer(0, index_type()), expr.type());
+        exprt index_expr =
+          index_exprt(object, from_integer(0, index_type()), expr.type());
 
         // adjust type?
         if(object.type() != array_type)

src/util/expr.h

@@ -319,6 +319,40 @@ class exprt:public irept
   const_unique_depth_iteratort unique_depth_cend() const;
 };
 
+/// Protected class for all expressions.
+/// This API will eventually replace exprt.
+class expr_protectedt : public exprt
+{
+protected:
+  // constructors
+  DEPRECATED("use expr_protectedt(id, type) instead")
+  expr_protectedt() : exprt()
+  {
+  }
+
+  DEPRECATED("use expr_protectedt(id, type) instead")
+  explicit expr_protectedt(const irep_idt &_id) : exprt(_id)
+  {
+  }
+
+  expr_protectedt(const irep_idt &_id, const typet &_type) : exprt(_id, _type)
+  {
+  }
+
+  // protect these low-level methods
+  using exprt::make_bool;
+  using exprt::make_typecast;
+  using exprt::op0;
+  using exprt::op1;
+  using exprt::op2;
+  using exprt::op3;
+  // using exprt::find;
+  // using exprt::get;
+  // using exprt::set;
+  using exprt::add;
+  using exprt::remove;
+};
+
 class expr_visitort
 {
 public:

src/util/pointer_offset_size.cpp

@@ -593,8 +593,11 @@ exprt build_sizeof_expr(
   const constant_exprt &expr,
   const namespacet &ns)
 {
-  const typet &type=
-    static_cast<const typet &>(expr.find(ID_C_c_sizeof_type));
+  // need to cast down to access 'find'
+  const auto &expr_as_irep = static_cast<const irept &>(expr);
+
+  const typet &type =
+    static_cast<const typet &>(expr_as_irep.find(ID_C_c_sizeof_type));
 
   if(type.is_nil())
     return nil_exprt();

src/util/std_expr.cpp

@@ -150,8 +150,8 @@ extractbits_exprt::extractbits_exprt(
   const exprt &_src,
   const std::size_t _upper,
   const std::size_t _lower,
-  const typet &_type):
-  exprt(ID_extractbits, _type)
+  const typet &_type)
+  : expr_protectedt(ID_extractbits, _type)
 {
   PRECONDITION(_upper >= _lower);
   operands().resize(3);