refactor: use recursive crate, add missing recursive tag

Cargo.toml

@@ -65,6 +65,7 @@ rayon = "1.9"
 regex = "1.9"
 reqwest = { version = "0.11", default-features = false }
 ryu = "1.0.13"
+recursive = "0.1"
 serde = "1.0.188"
 serde_json = "1"
 simd-json = { version = "0.13", features = ["known-key"] }

crates/polars-plan/Cargo.toml

@@ -33,6 +33,7 @@ once_cell = { workspace = true }
 percent-encoding = { workspace = true }
 pyo3 = { workspace = true, optional = true }
 rayon = { workspace = true }
+recursive = { workspace = true }
 regex = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive", "rc"], optional = true }
 smartstring = { workspace = true }

crates/polars-plan/src/logical_plan/aexpr/schema.rs

@@ -1,3 +1,5 @@
+use recursive::recursive;
+
 use super::*;
 
 fn float_type(field: &mut Field) {
@@ -10,6 +12,7 @@ fn float_type(field: &mut Field) {
 
 impl AExpr {
     /// Get Field result of the expression. The schema is the input data.
+    #[recursive]
     pub fn to_field(
         &self,
         schema: &Schema,

crates/polars-plan/src/logical_plan/conversion.rs

@@ -1,5 +1,6 @@
 use polars_core::prelude::*;
 use polars_utils::vec::ConvertVec;
+use recursive::recursive;
 
 use crate::constants::get_len_name;
 use crate::prelude::*;
@@ -62,7 +63,8 @@ fn to_aexprs(input: Vec<Expr>, arena: &mut Arena<AExpr>, state: &mut ConversionS
         .collect()
 }
 
-/// converts expression to AExpr and adds it to the arena, which uses an arena (Vec) for allocation
+/// Converts expression to AExpr and adds it to the arena, which uses an arena (Vec) for allocation.
+#[recursive]
 fn to_aexpr_impl(expr: Expr, arena: &mut Arena<AExpr>, state: &mut ConversionState) -> Node {
     let v = match expr {
         Expr::Explode(expr) => AExpr::Explode(to_aexpr_impl(*expr, arena, state)),
@@ -261,6 +263,7 @@ fn to_aexpr_impl(expr: Expr, arena: &mut Arena<AExpr>, state: &mut ConversionSta
 /// converts LogicalPlan to ALogicalPlan
 /// it adds expressions & lps to the respective arenas as it traverses the plan
 /// finally it returns the top node of the logical plan
+#[recursive]
 pub fn to_alp(
     lp: LogicalPlan,
     expr_arena: &mut Arena<AExpr>,
@@ -474,6 +477,7 @@ pub fn to_alp(
 }
 
 /// converts a node from the AExpr arena to Expr
+#[recursive]
 pub fn node_to_expr(node: Node, expr_arena: &Arena<AExpr>) -> Expr {
     let expr = expr_arena.get(node).clone();
 
@@ -705,6 +709,7 @@ fn expr_irs_to_exprs(expr_irs: Vec<ExprIR>, expr_arena: &Arena<AExpr>) -> Vec<Ex
 }
 
 impl ALogicalPlan {
+    #[recursive]
     fn into_lp<F, LPA>(
         self,
         conversion_fn: &F,

crates/polars-plan/src/logical_plan/mod.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
 use polars_core::prelude::*;
-use polars_utils::recursion::with_dynamic_stack;
+use recursive::recursive;
 
 use crate::logical_plan::LogicalPlan::DataFrameScan;
 use crate::prelude::*;
@@ -250,30 +250,29 @@ impl Clone for LogicalPlan {
     // calls clone on every member of every enum variant.
     #[rustfmt::skip]
     #[allow(clippy::clone_on_copy)]
+    #[recursive]
     fn clone(&self) -> Self {
-        with_dynamic_stack(|| {
-            match self {
-                #[cfg(feature = "python")]
-                Self::PythonScan { options } => Self::PythonScan { options: options.clone() },
-                Self::Selection { input, predicate } => Self::Selection { input: input.clone(), predicate: predicate.clone() },
-                Self::Cache { input, id, cache_hits } => Self::Cache { input: input.clone(), id: id.clone(), cache_hits: cache_hits.clone() },
-                Self::Scan { paths, file_info, predicate, file_options, scan_type } => Self::Scan { paths: paths.clone(), file_info: file_info.clone(), predicate: predicate.clone(), file_options: file_options.clone(), scan_type: scan_type.clone() },
-                Self::DataFrameScan { df, schema, output_schema, projection, selection } => Self::DataFrameScan { df: df.clone(), schema: schema.clone(), output_schema: output_schema.clone(), projection: projection.clone(), selection: selection.clone() },
-                Self::Projection { expr, input, schema, options } => Self::Projection { expr: expr.clone(), input: input.clone(), schema: schema.clone(), options: options.clone() },
-                Self::Aggregate { input, keys, aggs, schema, apply, maintain_order, options } => Self::Aggregate { input: input.clone(), keys: keys.clone(), aggs: aggs.clone(), schema: schema.clone(), apply: apply.clone(), maintain_order: maintain_order.clone(), options: options.clone() },
-                Self::Join { input_left, input_right, schema, left_on, right_on, options } => Self::Join { input_left: input_left.clone(), input_right: input_right.clone(), schema: schema.clone(), left_on: left_on.clone(), right_on: right_on.clone(), options: options.clone() },
-                Self::HStack { input, exprs, schema, options } => Self::HStack { input: input.clone(), exprs: exprs.clone(), schema: schema.clone(), options: options.clone() },
-                Self::Distinct { input, options } => Self::Distinct { input: input.clone(), options: options.clone() },
-                Self::Sort { input, by_column, args } => Self::Sort { input: input.clone(), by_column: by_column.clone(), args: args.clone() },
-                Self::Slice { input, offset, len } => Self::Slice { input: input.clone(), offset: offset.clone(), len: len.clone() },
-                Self::MapFunction { input, function } => Self::MapFunction { input: input.clone(), function: function.clone() },
-                Self::Union { inputs, options } => Self::Union { inputs: inputs.clone(), options: options.clone() },
-                Self::HConcat { inputs, schema, options } => Self::HConcat { inputs: inputs.clone(), schema: schema.clone(), options: options.clone() },
-                Self::Error { input, err } => Self::Error { input: input.clone(), err: err.clone() },
-                Self::ExtContext { input, contexts, schema } => Self::ExtContext { input: input.clone(), contexts: contexts.clone(), schema: schema.clone() },
-                Self::Sink { input, payload } => Self::Sink { input: input.clone(), payload: payload.clone() },
-            }
-        })
+        match self {
+            #[cfg(feature = "python")]
+            Self::PythonScan { options } => Self::PythonScan { options: options.clone() },
+            Self::Selection { input, predicate } => Self::Selection { input: input.clone(), predicate: predicate.clone() },
+            Self::Cache { input, id, cache_hits } => Self::Cache { input: input.clone(), id: id.clone(), cache_hits: cache_hits.clone() },
+            Self::Scan { paths, file_info, predicate, file_options, scan_type } => Self::Scan { paths: paths.clone(), file_info: file_info.clone(), predicate: predicate.clone(), file_options: file_options.clone(), scan_type: scan_type.clone() },
+            Self::DataFrameScan { df, schema, output_schema, projection, selection } => Self::DataFrameScan { df: df.clone(), schema: schema.clone(), output_schema: output_schema.clone(), projection: projection.clone(), selection: selection.clone() },
+            Self::Projection { expr, input, schema, options } => Self::Projection { expr: expr.clone(), input: input.clone(), schema: schema.clone(), options: options.clone() },
+            Self::Aggregate { input, keys, aggs, schema, apply, maintain_order, options } => Self::Aggregate { input: input.clone(), keys: keys.clone(), aggs: aggs.clone(), schema: schema.clone(), apply: apply.clone(), maintain_order: maintain_order.clone(), options: options.clone() },
+            Self::Join { input_left, input_right, schema, left_on, right_on, options } => Self::Join { input_left: input_left.clone(), input_right: input_right.clone(), schema: schema.clone(), left_on: left_on.clone(), right_on: right_on.clone(), options: options.clone() },
+            Self::HStack { input, exprs, schema, options } => Self::HStack { input: input.clone(), exprs: exprs.clone(), schema: schema.clone(), options: options.clone() },
+            Self::Distinct { input, options } => Self::Distinct { input: input.clone(), options: options.clone() },
+            Self::Sort { input, by_column, args } => Self::Sort { input: input.clone(), by_column: by_column.clone(), args: args.clone() },
+            Self::Slice { input, offset, len } => Self::Slice { input: input.clone(), offset: offset.clone(), len: len.clone() },
+            Self::MapFunction { input, function } => Self::MapFunction { input: input.clone(), function: function.clone() },
+            Self::Union { inputs, options } => Self::Union { inputs: inputs.clone(), options: options.clone() },
+            Self::HConcat { inputs, schema, options } => Self::HConcat { inputs: inputs.clone(), schema: schema.clone(), options: options.clone() },
+            Self::Error { input, err } => Self::Error { input: input.clone(), err: err.clone() },
+            Self::ExtContext { input, contexts, schema } => Self::ExtContext { input: input.clone(), contexts: contexts.clone(), schema: schema.clone() },
+            Self::Sink { input, payload } => Self::Sink { input: input.clone(), payload: payload.clone() },
+        }
     }
 }