fix: Remove outdated depth warning (#22030)

Author: orlp

Diff for: Cargo.lock

@@ -24,6 +24,7 @@ polars-time = { workspace = true, optional = true }
 polars-utils = { workspace = true }
 rand = { workspace = true }
 rayon = { workspace = true }
+recursive = { workspace = true }
 
 [features]
 nightly = ["polars-core/nightly", "polars-plan/nightly"]

Diff for: crates/polars-expr/Cargo.toml

@@ -1,6 +1,7 @@
 use polars_core::prelude::*;
 use polars_plan::prelude::expr_ir::ExprIR;
 use polars_plan::prelude::*;
+use recursive::recursive;
 
 use crate::expressions as phys_expr;
 use crate::expressions::*;
@@ -97,47 +98,28 @@ pub struct ExpressionConversionState {
     // settings per expression
     // those are reset every expression
     local: LocalConversionState,
-    depth_limit: u16,
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Default)]
 struct LocalConversionState {
     has_implode: bool,
     has_window: bool,
     has_lit: bool,
-    // Max depth an expression may have.
-    // 0 is unlimited.
-    depth_limit: u16,
-}
-
-impl Default for LocalConversionState {
-    fn default() -> Self {
-        Self {
-            has_lit: false,
-            has_implode: false,
-            has_window: false,
-            depth_limit: 500,
-        }
-    }
 }
 
 impl ExpressionConversionState {
-    pub fn new(allow_threading: bool, depth_limit: u16) -> Self {
+    pub fn new(allow_threading: bool) -> Self {
         Self {
-            depth_limit,
             allow_threading,
             has_windows: false,
             local: LocalConversionState {
-                depth_limit,
                 ..Default::default()
             },
         }
     }
+
     fn reset(&mut self) {
-        self.local = LocalConversionState {
-            depth_limit: self.depth_limit,
-            ..Default::default()
-        }
+        self.local = LocalConversionState::default();
     }
 
     fn has_implode(&self) -> bool {
@@ -148,19 +130,6 @@ impl ExpressionConversionState {
         self.has_windows = true;
         self.local.has_window = true;
     }
-
-    fn check_depth(&mut self) {
-        if self.local.depth_limit > 0 {
-            self.local.depth_limit -= 1;
-
-            if self.local.depth_limit == 0 {
-                let depth = get_expr_depth_limit().unwrap();
-                polars_warn!(format!(
-                    "encountered expression deeper than {depth} elements; this may overflow the stack, consider refactoring"
-                ))
-            }
-        }
-    }
 }
 
 pub fn create_physical_expr(
@@ -183,6 +152,7 @@ pub fn create_physical_expr(
     }
 }
 
+#[recursive]
 fn create_physical_expr_inner(
     expression: Node,
     ctxt: Context,
@@ -192,8 +162,6 @@ fn create_physical_expr_inner(
 ) -> PolarsResult<Arc<dyn PhysicalExpr>> {
     use AExpr::*;
 
-    state.check_depth();
-
     match expr_arena.get(expression) {
         Len => Ok(Arc::new(phys_expr::CountExpr::new())),
         Window {

Diff for: crates/polars-expr/src/planner.rs

@@ -62,7 +62,7 @@ pub trait ExprEvalExtension: IntoExpr + Sized {
                 Context::Default,
                 &arena,
                 &schema,
-                &mut ExpressionConversionState::new(true, 0),
+                &mut ExpressionConversionState::new(true),
             )?;
 
             let state = ExecutionState::new();

Diff for: crates/polars-lazy/src/dsl/eval.rs

@@ -637,7 +637,7 @@ impl LazyFrame {
                     Context::Default,
                     expr_arena,
                     schema,
-                    &mut ExpressionConversionState::new(true, 0),
+                    &mut ExpressionConversionState::new(true),
                 )
                 .ok()?;
                 let io_expr = phys_expr_to_io_expr(phys_expr);

Diff for: crates/polars-lazy/src/frame/mod.rs

@@ -43,6 +43,6 @@ pub(crate) fn prepare_expression_for_context(
         ctxt,
         &expr_arena,
         &input_schema,
-        &mut ExpressionConversionState::new(true, 0),
+        &mut ExpressionConversionState::new(true),
     )
 }

Diff for: crates/polars-lazy/src/physical_plan/exotic.rs

@@ -56,7 +56,7 @@ fn to_physical_piped_expr(
         Context::Default,
         expr_arena,
         schema,
-        &mut ExpressionConversionState::new(false, 0),
+        &mut ExpressionConversionState::new(false),
     )
     .map(|e| Arc::new(Wrap(e)) as Arc<dyn PhysicalPipedExpr>)
 }

Diff for: crates/polars-lazy/src/physical_plan/streaming/construct_pipeline.rs

@@ -53,15 +53,13 @@ fn partitionable_gb(
 
 #[derive(Clone)]
 struct ConversionState {
-    expr_depth: u16,
     has_cache_child: bool,
     has_cache_parent: bool,
 }
 
 impl ConversionState {
     fn new() -> PolarsResult<Self> {
         Ok(ConversionState {
-            expr_depth: get_expr_depth_limit()?,
             has_cache_child: false,
             has_cache_parent: false,
         })
@@ -212,7 +210,7 @@ fn create_physical_plan_impl(
     match logical_plan {
         #[cfg(feature = "python")]
         PythonScan { mut options } => {
-            let mut expr_conv_state = ExpressionConversionState::new(true, state.expr_depth);
+            let mut expr_conv_state = ExpressionConversionState::new(true);
             let (predicate, predicate_serialized) =
                 python_scan_predicate(&mut options, expr_arena, &mut expr_conv_state)?;
             Ok(Box::new(executors::PythonScanExec {
@@ -457,7 +455,7 @@ fn create_physical_plan_impl(
                     }
             }
             let input = recurse!(input, state)?;
-            let mut state = ExpressionConversionState::new(true, state.expr_depth);
+            let mut state = ExpressionConversionState::new(true);
             let predicate = create_physical_expr(
                 &predicate,
                 Context::Default,
@@ -488,7 +486,7 @@ fn create_physical_plan_impl(
                 _set_n_rows_for_scan(None).map(|x| (0, x))
             };
 
-            let mut state = ExpressionConversionState::new(true, state.expr_depth);
+            let mut state = ExpressionConversionState::new(true);
             let do_new_multifile = (sources.len() > 1 || hive_parts.is_some())
                 && !matches!(&*scan_type, FileScan::Anonymous { .. })
                 && std::env::var("POLARS_NEW_MULTIFILE").as_deref() == Ok("1");
@@ -601,10 +599,7 @@ fn create_physical_plan_impl(
         } => {
             let input_schema = lp_arena.get(input).schema(lp_arena).into_owned();
             let input = recurse!(input, state)?;
-            let mut state = ExpressionConversionState::new(
-                POOL.current_num_threads() > expr.len(),
-                state.expr_depth,
-            );
+            let mut state = ExpressionConversionState::new(POOL.current_num_threads() > expr.len());
             let phys_expr = create_physical_expressions_from_irs(
                 &expr,
                 Context::Default,
@@ -648,7 +643,7 @@ fn create_physical_plan_impl(
                 Context::Default,
                 expr_arena,
                 input_schema.as_ref(),
-                &mut ExpressionConversionState::new(true, state.expr_depth),
+                &mut ExpressionConversionState::new(true),
             )?;
             let input = recurse!(input, state)?;
             Ok(Box::new(executors::SortExec {
@@ -704,14 +699,14 @@ fn create_physical_plan_impl(
                 Context::Default,
                 expr_arena,
                 &input_schema,
-                &mut ExpressionConversionState::new(true, state.expr_depth),
+                &mut ExpressionConversionState::new(true),
             )?;
             let phys_aggs = create_physical_expressions_from_irs(
                 &aggs,
                 Context::Aggregation,
                 expr_arena,
                 &input_schema,
-                &mut ExpressionConversionState::new(true, state.expr_depth),
+                &mut ExpressionConversionState::new(true),
             )?;
 
             let _slice = options.slice;
@@ -820,14 +815,14 @@ fn create_physical_plan_impl(
                 Context::Default,
                 expr_arena,
                 &schema_left,
-                &mut ExpressionConversionState::new(true, state.expr_depth),
+                &mut ExpressionConversionState::new(true),
             )?;
             let right_on = create_physical_expressions_from_irs(
                 &right_on,
                 Context::Default,
                 expr_arena,
                 &schema_right,
-                &mut ExpressionConversionState::new(true, state.expr_depth),
+                &mut ExpressionConversionState::new(true),
             )?;
             let options = Arc::try_unwrap(options).unwrap_or_else(|options| (*options).clone());
 
@@ -842,7 +837,7 @@ fn create_physical_plan_impl(
                             Context::Default,
                             expr_arena,
                             &schema,
-                            &mut ExpressionConversionState::new(false, state.expr_depth),
+                            &mut ExpressionConversionState::new(false),
                         )?;
 
                         let execution_state = ExecutionState::default();
@@ -881,10 +876,8 @@ fn create_physical_plan_impl(
                     .iter()
                     .all(|e| is_elementwise_rec_no_cat_cast(expr_arena.get(e.node()), expr_arena));
 
-            let mut state = ExpressionConversionState::new(
-                POOL.current_num_threads() > exprs.len(),
-                state.expr_depth,
-            );
+            let mut state =
+                ExpressionConversionState::new(POOL.current_num_threads() > exprs.len());
 
             let phys_exprs = create_physical_expressions_from_irs(
                 &exprs,

Diff for: crates/polars-mem-engine/src/planner/lp.rs

@@ -4,7 +4,6 @@ use polars_core::frame::DataFrame;
 use polars_core::prelude::{DataType, Field, InitHashMaps, PlHashMap, PlHashSet};
 use polars_core::schema::{Schema, SchemaExt};
 use polars_error::PolarsResult;
-use polars_expr::planner::get_expr_depth_limit;
 use polars_expr::state::ExecutionState;
 use polars_expr::{ExpressionConversionState, create_physical_expr};
 use polars_ops::frame::{JoinArgs, JoinType};
@@ -384,8 +383,7 @@ fn build_fallback_node_with_ctx(
     };
 
     let output_schema = schema_for_select(input_stream, exprs, ctx)?;
-    let expr_depth_limit = get_expr_depth_limit()?;
-    let mut conv_state = ExpressionConversionState::new(false, expr_depth_limit);
+    let mut conv_state = ExpressionConversionState::new(false);
     let phys_exprs = exprs
         .iter()
         .map(|expr| {

Diff for: crates/polars-stream/src/physical_plan/lower_expr.rs

@@ -6,7 +6,7 @@ use polars_core::prelude::PlRandomState;
 use polars_core::schema::Schema;
 use polars_error::{PolarsResult, polars_bail, polars_ensure, polars_err};
 use polars_expr::groups::new_hash_grouper;
-use polars_expr::planner::{ExpressionConversionState, create_physical_expr, get_expr_depth_limit};
+use polars_expr::planner::{ExpressionConversionState, create_physical_expr};
 use polars_expr::reduce::into_reduction;
 use polars_expr::state::ExecutionState;
 use polars_mem_engine::{create_physical_plan, create_scan_predicate};
@@ -75,13 +75,12 @@ pub fn physical_plan_to_graph(
 ) -> PolarsResult<(Graph, SecondaryMap<PhysNodeKey, GraphNodeKey>)> {
     // Get the number of threads from the rayon thread-pool as that respects our config.
     let num_pipelines = POOL.current_num_threads();
-    let expr_depth_limit = get_expr_depth_limit()?;
     let mut ctx = GraphConversionContext {
         phys_sm,
         expr_arena,
         graph: Graph::with_capacity(phys_sm.len()),
         phys_to_graph: SecondaryMap::with_capacity(phys_sm.len()),
-        expr_conversion_state: ExpressionConversionState::new(false, expr_depth_limit),
+        expr_conversion_state: ExpressionConversionState::new(false),
         num_pipelines,
     };