recursion limit exceeded

use serde::de::IgnoredAny;
use serde::{Deserialize, Serialize};
use serde_json::Value;

fn arrays(depth: usize) -> String {
  format!("{}{}", "[".repeat(depth), "]".repeat(depth))
}

// A tree: every level is one JSON object plus one JSON array.
#[derive(Serialize, Deserialize, Debug)]
struct Node {
  children: Vec<Node>,
}

fn chain(levels: usize) -> Node {
  let mut node = Node { children: vec![] };
  for _ in 1..levels {
    node = Node { children: vec![node] };
  }
  node
}

fn main() {
  for depth in [127, 128] {
    let r = serde_json::from_str::<Value>(&arrays(depth)).map(|_| ()).map_err(|e| e.to_string());
    println!("Value, {depth} arrays: {r:?}");
  }
  for levels in [63, 64] {
    // serialization has no depth check
    let text = serde_json::to_string(&chain(levels)).unwrap();
    let r = serde_json::from_str::<Node>(&text).map(|_| ()).map_err(|e| e.to_string());
    println!("Node, {levels} levels, {} brackets: to_string Ok, from_str {r:?}", text.matches(['[', '{']).count());
  }
  let e = serde_json::from_str::<Value>(&arrays(128)).unwrap_err();
  println!("classify: {:?}", e.classify());
  let r = serde_json::from_str::<IgnoredAny>(&arrays(100_000));
  println!("IgnoredAny, 100000 arrays: {r:?}");
}

Value, 127 arrays: Ok(())
Value, 128 arrays: Err("recursion limit exceeded at line 1 column 128")
Node, 63 levels, 126 brackets: to_string Ok, from_str Ok(())
Node, 64 levels, 128 brackets: to_string Ok, from_str Err("recursion limit exceeded at line 1 column 832")
classify: Syntax
IgnoredAny, 100000 arrays: Ok(IgnoredAny)

use serde_json::Value;

fn main() {
  let mut v = Value::Null;
  for _ in 0..200 {
    v = Value::Array(vec![v]);
  }
  let text = serde_json::to_string(&v).unwrap();
  println!("from_str:   {:?}", serde_json::from_str::<Value>(&text).map(|_| ()).map_err(|e| e.to_string()));
  println!("from_value: {:?}", serde_json::from_value::<Value>(v).map(|_| ()).map_err(|e| e.to_string()));
}

from_str:   Err("recursion limit exceeded at line 1 column 128")
from_value: Ok(())

        if_checking_recursion_limit! {
            $this.remaining_depth -= 1;
            if $this.remaining_depth == 0 {
                return Err($this.peek_error(ErrorCode::RecursionLimitExceeded));
            }
        }

use serde::Deserialize;
use serde_json::Value;

fn arrays(depth: usize) -> String {
  format!("{}{}", "[".repeat(depth), "]".repeat(depth))
}

// Drops a deep Value without recursing (Value's own Drop recurses).
fn drop_flat(value: Value) {
  let mut stack = vec![value];
  while let Some(value) = stack.pop() {
    if let Value::Array(array) = value {
      stack.extend(array);
    }
  }
}

fn parse_unbounded(json: &str) -> bool {
  let mut de = serde_json::Deserializer::from_str(json);
  de.disable_recursion_limit();
  let value = Value::deserialize(&mut de);
  let ok = value.is_ok();
  if let Ok(v) = value {
    drop_flat(v);
  }
  ok
}

fn main() {
  let depth: usize = std::env::args().nth(1).unwrap().parse().unwrap();
  let stack_mb: usize = std::env::args().nth(2).map(|s| s.parse().unwrap()).unwrap_or(0);
  let json = arrays(depth);
  if stack_mb == 0 {
    println!("depth {depth}, main thread: parsed = {}", parse_unbounded(&json));
  } else {
    let handle = std::thread::Builder::new()
      .stack_size(stack_mb << 20)
      .spawn(move || parse_unbounded(&json))
      .unwrap();
    println!("depth {depth}, thread with {stack_mb} MiB stack: parsed = {}", handle.join().unwrap());
  }
}

== 10000

thread 'main' (2838196) has overflowed its stack
fatal runtime error: stack overflow, aborting
exit=134
== 10000 256
depth 10000, thread with 256 MiB stack: parsed = true
exit=0
== 100000 256
depth 100000, thread with 256 MiB stack: parsed = true
exit=0
== 1000000 256

thread '<unknown>' (2838272) has overflowed its stack
fatal runtime error: stack overflow, aborting
exit=134