revert9

datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs

@@ -31,7 +31,7 @@ use arrow::{
     datatypes::{DataType, Field, Schema},
     record_batch::RecordBatch,
 };
-use datafusion_common::tree_node::TreeNodeRecursion;
+use datafusion_common::tree_node::{RewriteRecursion, TreeNodeRewriterOld};
 use datafusion_common::{
     cast::{as_large_list_array, as_list_array},
     plan_err,
@@ -140,12 +140,12 @@ impl<S: SimplifyInfo> ExprSimplifier<S> {
         // (evaluating constants can enable new simplifications and
         // simplifications can enable new constant evaluation)
         // https://github.com/apache/arrow-datafusion/issues/1160
-        expr.rewrite(&mut const_evaluator)?
+        expr.rewrite_old(&mut const_evaluator)?
             .rewrite(&mut simplifier)?
             .rewrite(&mut or_in_list_simplifier)?
             .rewrite_old(&mut guarantee_rewriter)?
             // run both passes twice to try an minimize simplifications that we missed
-            .rewrite(&mut const_evaluator)?
+            .rewrite_old(&mut const_evaluator)?
             .rewrite(&mut simplifier)
     }
 
@@ -250,18 +250,18 @@ struct ConstEvaluator<'a> {
     input_batch: RecordBatch,
 }
 
-impl<'a> TreeNodeRewriter for ConstEvaluator<'a> {
-    type Node = Expr;
+impl<'a> TreeNodeRewriterOld for ConstEvaluator<'a> {
+    type N = Expr;
 
-    fn f_down(&mut self, expr: Expr) -> Result<(Expr, TreeNodeRecursion)> {
+    fn pre_visit(&mut self, expr: &Expr) -> Result<RewriteRecursion> {
         // Default to being able to evaluate this node
         self.can_evaluate.push(true);
 
         // if this expr is not ok to evaluate, mark entire parent
         // stack as not ok (as all parents have at least one child or
         // descendant that can not be evaluated
 
-        if !Self::can_evaluate(&expr) {
+        if !Self::can_evaluate(expr) {
             // walk back up stack, marking first parent that is not mutable
             let parent_iter = self.can_evaluate.iter_mut().rev();
             for p in parent_iter {
@@ -277,10 +277,10 @@ impl<'a> TreeNodeRewriter for ConstEvaluator<'a> {
         // NB: do not short circuit recursion even if we find a non
         // evaluatable node (so we can fold other children, args to
         // functions, etc)
-        Ok((expr, TreeNodeRecursion::Continue))
+        Ok(RewriteRecursion::Continue)
     }
 
-    fn f_up(&mut self, expr: Expr) -> Result<Expr> {
+    fn mutate(&mut self, expr: Expr) -> Result<Expr> {
         match self.can_evaluate.pop() {
             Some(true) => Ok(Expr::Literal(self.evaluate_to_scalar(expr)?)),
             Some(false) => Ok(expr),
@@ -1425,7 +1425,7 @@ mod tests {
         let mut const_evaluator = ConstEvaluator::try_new(&execution_props).unwrap();
         let evaluated_expr = input_expr
             .clone()
-            .rewrite(&mut const_evaluator)
+            .rewrite_old(&mut const_evaluator)
             .expect("successfully evaluated");
 
         assert_eq!(