pre/post traversal expression transformers

Transformers for expressions that offer an interface similar to that offered
by the goto-program API. Both pre- and post-traversal options are available.

The key benefit over the non-const visit method is that sharing is only
broken up when required.

Author: Daniel Kroening

Diff for: src/util/expr.cpp

@@ -287,6 +287,65 @@ void exprt::visit_post(std::function<void(const exprt &)> visitor) const
   visit_post_template(visitor, this);
 }
 
+optionalt<exprt>
+exprt::transform_pre(std::function<optionalt<exprt>(exprt)> visitor) const
+{
+  auto visitor_result = visitor(*this);
+
+  exprt tmp;
+
+  if(visitor_result.has_value())
+    tmp = visitor_result.value();
+  else
+    tmp = *this;
+
+  bool op_changed = false;
+
+  for(auto &op : tmp.operands()) // this breaks sharing
+  {
+    auto op_result = op.transform_pre(visitor);
+    if(op_result.has_value())
+    {
+      op = std::move(op_result.value());
+      op_changed = true;
+    }
+  }
+
+  if(op_changed)
+    return std::move(tmp);
+  else
+    return visitor_result;
+}
+
+optionalt<exprt>
+exprt::transform_post(std::function<optionalt<exprt>(exprt)> visitor) const
+{
+  exprt tmp = *this;
+  bool op_changed = false;
+
+  for(auto &op : tmp.operands()) // this breaks sharing
+  {
+    auto op_result = op.transform_post(visitor);
+    if(op_result.has_value())
+    {
+      op = std::move(op_result.value());
+      op_changed = true;
+    }
+  }
+
+  if(op_changed)
+  {
+    auto visitor_result = visitor(tmp);
+
+    if(visitor_result.has_value())
+      return std::move(visitor_result.value());
+    else
+      return std::move(tmp);
+  }
+  else
+    return visitor(*this);
+}
+
 template <typename T>
 static void visit_pre_template(std::function<void(T &)> visitor, T *_expr)
 {

Diff for: src/util/expr.h

@@ -332,12 +332,14 @@ class exprt:public irept
   void visit(class const_expr_visitort &visitor) const;
   void visit_pre(std::function<void(exprt &)>);
   void visit_pre(std::function<void(const exprt &)>) const;
+  optionalt<exprt> transform_pre(std::function<optionalt<exprt>(exprt)>) const;
 
   /// These are post-order traversal visitors, i.e.,
   /// the visitor is executed on a node _after_ its children
   /// have been visited.
   void visit_post(std::function<void(exprt &)>);
   void visit_post(std::function<void(const exprt &)>) const;
+  optionalt<exprt> transform_post(std::function<optionalt<exprt>(exprt)>) const;
 
   depth_iteratort depth_begin();
   depth_iteratort depth_end();