feat: introduce maximum parser recursion depth

[thevilledev]

Problem

Parsing extremely deeply nested structures (e.g., nested arrays [[[...]]], objects {a:{a:{...}}}, or long chains of unary/binary operators) could lead to excessive recursion in the C++ parser functions, potentially exhausting the native call stack and crashing the interpreter.

Solution

A constant MAX_PARSER_DEPTH (set to 1000) is introduced in core/parser.cpp. Recursive parsing functions (parse, parseArgs, parseParams, parseBind, parseObjectRemainder, parseComprehensionSpecs, parseTerminalBracketsOrUnary, maybeParseGreedy, parseInfix) now track the current recursion depth and throw a StaticError if this limit is exceeded. This ensures the parser terminates gracefully for pathological inputs instead of crashing.

The current_depth parameter is generally incremented by 1 whenever a parsing function makes a recursive call to parse a distinct sub-expression or nested structure (e.g., calling parse from within parseObjectRemainder to handle a field's value, or calling parse from parseInfix to handle the right-hand operand). This accurately tracks the syntactic nesting depth. Calls that are part of processing the same structural level (like parseParams calling parseArgs internally) might pass the depth unchanged.

A new test case (test_suite/error.parse.deep_array_nesting.jsonnet) has been added to verify that the depth limit is correctly enforced and produces the expected static error. This test case uses deeply nested arrays, which demonstrably causes a segmentation fault on the master branch due to native stack overflow during parsing, but is now caught gracefully by the introduced limit.

I also updated all function doc strings as they were either missing or outdated.

Why a constant?

Making this limit a constant (rather than a command-line configurable option like --max-stack) was a deliberate design choice at this point:

• MAX_PARSER_DEPTH guards the parsing stage against C++ stack overflows, while --max-stack limits the evaluation stage's Jsonnet VM call stack.
• Exceeding a parse depth of 1000 is highly unlikely for typical, human-written Jsonnet code. It often indicates a structural issue in the code itself rather than a need for a higher limit.
• Adding a configuration option would increase CLI complexity and require plumbing the value through the library.

That being said, this is open for discussion and feedback.

NOTE: originally reported through Google OSS VRP and public disclosure was preferred.