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/analyses/goto_check.cpp

@@ -1293,7 +1293,7 @@ void goto_checkt::bounds_check(
     const exprt &pointer=
       to_dereference_expr(ode.root_object()).pointer();
 
-    if_exprt size(
+    exprt size = if_exprt(
       dynamic_object(pointer),
       typecast_exprt(dynamic_size(ns), object_size(pointer).type()),
       object_size(pointer));

src/ansi-c/expr2c.cpp

@@ -1941,9 +1941,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-") ||
@@ -1953,7 +1955,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

@@ -392,13 +392,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

@@ -870,8 +870,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

@@ -981,8 +981,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

@@ -674,8 +674,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/solvers/flattening/arrays.cpp

@@ -546,7 +546,7 @@ void arrayst::add_array_constraints_with(
       {
         const typet &subtype = expr.type().subtype();
         index_exprt index_expr1(expr, other_index, subtype);
-        index_exprt index_expr2(expr.op0(), other_index, subtype);
+        index_exprt index_expr2(expr.old(), other_index, subtype);
 
         equal_exprt equality_expr(index_expr1, index_expr2);
 
@@ -646,12 +646,12 @@ void arrayst::add_array_constraints_array_of(
     index_exprt index_expr(expr, index, subtype);
 
     DATA_INVARIANT(
-      base_type_eq(index_expr.type(), expr.op0().type(), ns),
+      base_type_eq(index_expr.type(), expr.what().type(), ns),
       "array_of operand type should match array element type");
 
     // add constraint
     lazy_constraintt lazy(
-      lazy_typet::ARRAY_OF, equal_exprt(index_expr, expr.op0()));
+      lazy_typet::ARRAY_OF, equal_exprt(index_expr, expr.what()));
     add_array_constraint(lazy, false); // added immediately
   }
 }

src/solvers/flattening/boolbv_array_of.cpp

@@ -42,7 +42,7 @@ bvt boolbvt::convert_array_of(const array_of_exprt &expr)
   if(to_integer(array_size, size))
     return conversion_failed(expr);
 
-  const bvt &tmp=convert_bv(expr.op0());
+  const bvt &tmp = convert_bv(expr.what());
 
   INVARIANT(
     size * tmp.size() == width,

src/solvers/smt2/smt2_conv.cpp

@@ -3361,11 +3361,11 @@ void smt2_convt::convert_floatbv_div(const ieee_float_op_exprt &expr)
   if(use_FPA_theory)
   {
     out << "(fp.div ";
-    convert_rounding_mode_FPA(expr.op2());
+    convert_rounding_mode_FPA(expr.rounding_mode());
     out << " ";
-    convert_expr(expr.op0());
+    convert_expr(expr.lhs());
     out << " ";
-    convert_expr(expr.op1());
+    convert_expr(expr.rhs());
     out << ")";
   }
   else
@@ -3555,8 +3555,8 @@ void smt2_convt::convert_with(const with_exprt &expr)
   {
     const struct_typet &struct_type = to_struct_type(ns.follow(expr_type));
 
-    const exprt &index=expr.op1();
-    const exprt &value=expr.op2();
+    const exprt &index = expr.where();
+    const exprt &value = expr.new_value();
 
     const irep_idt &component_name=index.get(ID_component_name);
 
@@ -3569,7 +3569,7 @@ void smt2_convt::convert_with(const with_exprt &expr)
       const std::string &smt_typename = datatype_map.at(expr_type);
 
       out << "(update-" << smt_typename << "." << component_name << " ";
-      convert_expr(expr.op0());
+      convert_expr(expr.old());
       out << " ";
       convert_expr(value);
       out << ")";
@@ -3583,7 +3583,7 @@ void smt2_convt::convert_with(const with_exprt &expr)
         boolbv_width.get_member(struct_type, component_name);
 
       out << "(let ((?withop ";
-      convert_expr(expr.op0());
+      convert_expr(expr.old());
       out << ")) ";
 
       if(m.width==struct_width)
@@ -3626,7 +3626,7 @@ void smt2_convt::convert_with(const with_exprt &expr)
   {
     const union_typet &union_type = to_union_type(ns.follow(expr_type));
 
-    const exprt &value=expr.op2();
+    const exprt &value = expr.new_value();
 
     std::size_t total_width=boolbv_width(union_type);
     CHECK_RETURN_WITH_DIAGNOSTICS(
@@ -3651,7 +3651,7 @@ void smt2_convt::convert_with(const with_exprt &expr)
       out << "((_ extract "
           << (total_width-1)
           << " " << member_width << ") ";
-      convert_expr(expr.op0());
+      convert_expr(expr.old());
       out << ") ";
       flatten2bv(value);
       out << ")";

src/util/expr.h

@@ -318,6 +318,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 protected_exprt : public exprt
+{
+protected:
+  // constructors
+  DEPRECATED("use protected_exprt(id, type) instead")
+  protected_exprt() : exprt()
+  {
+  }
+
+  DEPRECATED("use protected_exprt(id, type) instead")
+  explicit protected_exprt(const irep_idt &_id) : exprt(_id)
+  {
+  }
+
+  protected_exprt(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

@@ -595,8 +595,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/simplify_expr.cpp

@@ -1889,7 +1889,7 @@ bool simplify_exprt::simplify_byte_update(byte_update_exprt &expr)
             exprt compo_offset = from_integer(*i, offset.type());
             plus_exprt new_offset(offset, compo_offset);
             simplify_node(new_offset);
-            exprt new_value(with.op2());
+            exprt new_value(with.new_value());
             expr.op1().swap(new_offset);
             expr.op2().swap(new_value);
             simplify_byte_update(expr); // do this recursively
@@ -1916,7 +1916,7 @@ bool simplify_exprt::simplify_byte_update(byte_update_exprt &expr)
 
           plus_exprt new_offset(offset, index_offset);
           simplify_node(new_offset);
-          exprt new_value(with.op2());
+          exprt new_value(with.new_value());
           expr.op1().swap(new_offset);
           expr.op2().swap(new_value);
           simplify_byte_update(expr); // do this recursively

src/util/std_expr.cpp

@@ -149,8 +149,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)
+  : protected_exprt(ID_extractbits, _type)
 {
   PRECONDITION(_upper >= _lower);
   operands().resize(3);