Heredoc and outer-context recovery at recursion depth / stack budget limit causes location underflow #4367

#include <inttypes.h>
#include <prism.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    size_t size;
    size_t oob_nodes;
    pm_node_type_t first_type;
    uint32_t first_start;
    uint32_t first_length;
} check_result_t;

static pm_visit_result_t
check_node_bounds(const pm_node_t *node, void *data) {
    check_result_t *res = (check_result_t *) data;
    if (node->location.start > res->size || node->location.length > res->size - node->location.start) {
        if (res->oob_nodes == 0) {
            res->first_type = PM_NODE_TYPE(node);
            res->first_start = node->location.start;
            res->first_length = node->location.length;
        }
        res->oob_nodes++;
    }
    return PM_VISIT_DESCEND;
}

static size_t
run_case(const char *label, const uint8_t *source, size_t size, const pm_options_t *options) {
    pm_arena_t *arena = pm_arena_new();
    pm_parser_t *parser = pm_parser_new(arena, source, size, options);
    pm_node_t *root = pm_parse(parser);

    const pm_line_offset_list_t *line_offsets = pm_parser_line_offsets(parser);
    size_t bad_line_offsets = 0;
    if (line_offsets->size == 0 || line_offsets->offsets[0] != 0 ||
        line_offsets->offsets[line_offsets->size - 1] > size) {
        bad_line_offsets++;
    }
    for (size_t i = 1; i < line_offsets->size; i++) {
        if (line_offsets->offsets[i] <= line_offsets->offsets[i - 1]) {
            bad_line_offsets++;
        }
    }

    check_result_t res = { .size = size };
    pm_visit_node(root, check_node_bounds, &res);

    if (res.oob_nodes == 0 && bad_line_offsets == 0) {
        printf("[OK]   %-54s (size=%zu)\n", label, size);
    } else {
        printf(
            "[FAIL] %-54s (size=%zu): oob_nodes=%zu bad_line_offsets=%zu",
            label,
            size,
            res.oob_nodes,
            bad_line_offsets
        );
        if (res.oob_nodes > 0) {
            printf(
                " (first: %s start=%" PRIu32 " length=%" PRIu32 " [0x%08" PRIx32 "])",
                pm_node_type(res.first_type),
                res.first_start,
                res.first_length,
                res.first_length
            );
        }
        printf("\n");
    }

    pm_parser_free(parser);
    pm_arena_free(arena);
    return (res.oob_nodes > 0 || bad_line_offsets > 0) ? 1 : 0;
}

/* Pair 1: Stranded PM_LEX_HEREDOC via stack_budget on identical source */
static size_t
check_stranded_heredoc_stack_budget_pair(void) {
    static const uint8_t src[] = "f{f{f{<<0\n#{}}}\nclass";
    size_t failures = 0;

    failures += run_case("1a. stranded heredoc (unlimited stack)", src, sizeof(src) - 1, NULL);

    pm_options_t *options = pm_options_new();
    pm_options_stack_budget_set(options, 2048);
    failures += run_case("1b. stranded heredoc (stack_budget=2048)", src, sizeof(src) - 1, options);
    pm_options_free(options);

    return failures;
}

/* Pair 2: Stranded PM_LEX_HEREDOC just below vs. at PRISM_DEPTH_MAXIMUM (10000) */
static size_t
check_stranded_heredoc_depth_pair(void) {
    size_t failures = 0;
    const char mid[] = "<<0\n#{";
    const char tail[] = "\nclass";

    for (size_t blocks = 2499; blocks <= 2500; blocks++) {
        size_t size = (blocks * 2) + (sizeof(mid) - 1) + blocks + (sizeof(tail) - 1);
        uint8_t *src = malloc(size);
        for (size_t i = 0; i < blocks; i++) {
            src[2 * i] = 'f';
            src[2 * i + 1] = '{';
        }
        memcpy(src + (blocks * 2), mid, sizeof(mid) - 1);
        memset(src + (blocks * 2) + (sizeof(mid) - 1), '}', blocks);
        memcpy(src + (blocks * 2) + (sizeof(mid) - 1) + blocks, tail, sizeof(tail) - 1);

        char label[64];
        snprintf(
            label,
            sizeof(label),
            "2%c. stranded heredoc (blocks=%zu, %s)",
            blocks == 2499 ? 'a' : 'b',
            blocks,
            blocks == 2499 ? "depth < max" : "depth == max"
        );
        failures += run_case(label, src, size, NULL);
        free(src);
    }

    return failures;
}

/* Pair 3: Missing outer-context recovery via stack_budget on identical source */
static size_t
check_context_recovery_stack_budget_pair(void) {
    static const uint8_t src[] = "(<<0%\n#{[[[[[[v{)";
    size_t failures = 0;

    failures += run_case("3a. outer ')' recovery (unlimited stack)", src, sizeof(src) - 1, NULL);

    pm_options_t *options = pm_options_new();
    pm_options_stack_budget_set(options, 2048);
    failures += run_case("3b. outer ')' recovery (stack_budget=2048)", src, sizeof(src) - 1, options);
    pm_options_free(options);

    return failures;
}

/* Pair 4: Missing outer-context recovery just below vs. at PRISM_DEPTH_MAXIMUM (10000) */
static size_t
check_context_recovery_depth_pair(void) {
    size_t failures = 0;
    const char prefix[] = "(<<0%\n#{";
    const char suffix[] = "v{)";

    for (size_t brackets = 9990; brackets <= 9991; brackets++) {
        size_t size = (sizeof(prefix) - 1) + brackets + (sizeof(suffix) - 1);
        uint8_t *src = malloc(size);
        memcpy(src, prefix, sizeof(prefix) - 1);
        memset(src + (sizeof(prefix) - 1), '[', brackets);
        memcpy(src + (sizeof(prefix) - 1) + brackets, suffix, sizeof(suffix) - 1);

        char label[64];
        snprintf(
            label,
            sizeof(label),
            "4%c. outer ')' recovery (brackets=%zu, %s)",
            brackets == 9990 ? 'a' : 'b',
            brackets,
            brackets == 9990 ? "depth < max" : "depth == max"
        );
        failures += run_case(label, src, size, NULL);
        free(src);
    }

    return failures;
}

int
main(void) {
    size_t failures = 0;
    failures += check_stranded_heredoc_stack_budget_pair();
    failures += check_stranded_heredoc_depth_pair();
    failures += check_context_recovery_stack_budget_pair();
    failures += check_context_recovery_depth_pair();
    return failures == 0 ? 0 : 1;
}

if (PRISM_UNLIKELY(depth >= PRISM_DEPTH_MAXIMUM || pm_parser_stack_exhausted(parser))) {
    if (depth >= PRISM_DEPTH_MAXIMUM) {
        pm_parser_err_current(parser, PM_ERR_NESTING_TOO_DEEP);
    } else {
        pm_parser_err_stack_exhausted(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current));
    }

    return UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current)));
}

if (PM_NODE_TYPE_P(node, PM_ERROR_RECOVERY_NODE)) {
    parser_lex(parser);