#include "spl_parser.h"
#include "spl_lexer.h"
#include "spl_tok.h"

#define MOVE_VEC(dst, src)                                                                         \
    do {                                                                                           \
        (dst) = (src);                                                                             \
        vec_init(src);                                                                             \
    } while (0)

static char *sdupn(const char *s, usize n) {
    char *r = malloc(n + 1);
    if (!r)
        return NULL;
    memcpy(r, s, n);
    r[n] = '\0';
    return r;
}

static spl_dbg_node_t tok_to_dbg(const spl_tok_t *t) {
    spl_dbg_node_t d = {0};
    if (t) {
        d.fname = t->fname;
        d.line = (int)t->line;
        d.col = (int)t->col;
    }
    return d;
}

static void tok_desc(const spl_tok_t *t, char *buf, usize cap) {
    if (!t) {
        snprintf(buf, cap, "<no token>");
        return;
    }
    if (t->type == TOK_EOF) {
        snprintf(buf, cap, "EOF");
        return;
    }
    const char *kind = spl_tok_type_name(t->type);
    if (t->type == TOK_ENDLINE) {
        snprintf(buf, cap, "ENDLINE at %zu:%zu", t->line, t->col);
        return;
    }
    if (!t->lexeme || t->len == 0) {
        snprintf(buf, cap, "%s at %zu:%zu", kind, t->line, t->col);
        return;
    }
    int n = (int)(t->len > 32 ? 32 : t->len);
    snprintf(buf, cap, "%s `%.*s` at %s:%zu:%zu", kind, n, t->lexeme, t->fname, t->line, t->col);
}

#define PARSE_ERROR(p, kind, tok, fmt, ...)                                                        \
    do {                                                                                           \
        (p)->error_count++;                                                                        \
        if ((p)->diag) {                                                                           \
            char _tb[80];                                                                          \
            tok_desc((tok), _tb, sizeof _tb);                                                      \
            spl_dbg_node_t _pd = tok_to_dbg(tok);                                                  \
            spl_diag_error((p)->diag, (kind), &_pd, fmt " (got %s)", ##__VA_ARGS__, _tb);          \
        }                                                                                          \
    } while (0)

#define PARSE_FATAL(p, kind, tok, fmt, ...)                                                        \
    do {                                                                                           \
        (p)->failed = 1;                                                                           \
        (p)->error_count++;                                                                        \
        if ((p)->diag) {                                                                           \
            char _tb[80];                                                                          \
            tok_desc((tok), _tb, sizeof _tb);                                                      \
            spl_dbg_node_t _pd = tok_to_dbg(tok);                                                  \
            spl_diag_fatal((p)->diag, (kind), &_pd, fmt " (got %s)", ##__VA_ARGS__, _tb);          \
        }                                                                                          \
    } while (0)

static inline int is_trivia(spl_tok_type_t t) { return t == TOK_ENDLINE || t == TOK_LINE_COMMENT; }

static inline const spl_tok_t *peek(spl_parser_t *p) {
    usize n = vec_size(p->ast->input);
    usize i = p->pos;
    while (i < n && is_trivia(vec_at(p->ast->input, i).type))
        i++;
    p->pos = i;
    if (i >= n)
        return NULL;
    return &vec_at(p->ast->input, i);
}

static inline const spl_tok_t *advance(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (t && t->type != TOK_EOF)
        p->pos++;
    return t;
}

static inline spl_ast_node_t *node_at(spl_ast_t *ast, spl_ast_node_ref_t ref) {
    return &ast->node_buckets.data[ref];
}

static spl_ast_node_ref_t new_node(spl_parser_t *p, spl_ast_node_kind_t kind,
                                   const spl_tok_t *tok) {
    spl_ast_node_t n = {0};
    n.kind = kind;
    n.resolved_def_id = 0;
    n.resolved_lang_tid = 0;
    vec_init(n.attrs);
    if (tok) {
        n.dbg.fname = tok->fname;
        n.dbg.line = (int)tok->line;
        n.dbg.col = (int)tok->col;
    }
    vec_push(p->ast->node_buckets, n);
    return p->ast->node_buckets.size - 1;
}

static char *intern_string(spl_ast_t *ast, const char *s, usize len) {
    char *copy = sdupn(s, len);
    if (!copy)
        return NULL;
    vec_push(ast->str_buckets, copy);
    return copy;
}

#define SET_STR_FIELD(ast, field, tok)                                                             \
    do {                                                                                           \
        (field) = intern_string(ast, (tok)->lexeme, (tok)->len);                                   \
    } while (0)

static int expect(spl_parser_t *p, spl_tok_type_t tt, const char *what) {
    const spl_tok_t *t = peek(p);
    if (!t || t->type != tt) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected %s", what);
        return 0;
    }
    advance(p);
    return 1;
}

static isize parse_int_literal(const spl_tok_t *t) {
    char buf[128];
    usize j = 0;
    for (usize i = 0; i < t->len && j < sizeof(buf) - 1; i++) {
        if (t->lexeme[i] != '_')
            buf[j++] = t->lexeme[i];
    }
    buf[j] = 0;
    if (j >= 3 && buf[0] == '0' && (buf[1] == 'b' || buf[1] == 'B'))
        return (isize)strtoull(buf + 2, NULL, 2);
    if (j >= 3 && buf[0] == '0' && (buf[1] == 'o' || buf[1] == 'O'))
        return (isize)strtoull(buf + 2, NULL, 8);
    if (j >= 3 && buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X'))
        return (isize)strtoull(buf, NULL, 16);
    return (isize)strtoull(buf, NULL, 10);
}

static double parse_float_literal(const spl_tok_t *t) {
    char buf[128];
    usize j = 0;
    for (usize i = 0; i < t->len && j < sizeof(buf) - 1; i++) {
        if (t->lexeme[i] != '_')
            buf[j++] = t->lexeme[i];
    }
    buf[j] = 0;
    return strtod(buf, NULL);
}

static char parse_char_literal(const spl_tok_t *t) {
    const char *s = t->lexeme + 1;
    const char *end = t->lexeme + t->len - 1;
    char c = 0;
    if (s < end)
        spl_decode_escape(&s, &c);
    return c;
}

static char *parse_string_literal(spl_parser_t *p, const spl_tok_t *t, usize *out_len) {
    const char *src = t->lexeme + 1;
    const char *end = t->lexeme + t->len - 1;
    usize cap = t->len + 1;
    char *tmp = malloc(cap);
    if (!tmp) {
        *out_len = 0;
        return NULL;
    }
    char *dst = tmp;
    while (src < end) {
        char c;
        if (spl_decode_escape(&src, &c) == 0) {
            *dst++ = c;
        } else {
            *dst++ = *src;
            src++;
        }
    }
    *out_len = (usize)(dst - tmp);
    char *interned = intern_string(p->ast, tmp, dst - tmp);
    free(tmp);
    return interned;
}

static int can_start_expr(spl_tok_type_t t) {
    switch (t) {
    case TOK_INT_LITERAL:
    case TOK_FLOAT_LITERAL:
    case TOK_CHAR_LITERAL:
    case TOK_STRING_LITERAL:
    case KW_TRUE:
    case KW_FALSE:
    case KW_NULL:
    case KW_UNDEFINED:
    case TOK_IDENT:
    case TOK_AT:
    case TOK_SHARP:
    case TOK_DOLLAR:
    case TOK_L_PAREN:
    case TOK_L_BRACKET:
    case TOK_L_BRACE:
    case TOK_DOT:
    case TOK_SUB:
    case TOK_NOT:
    case TOK_BIT_NOT:
    case TOK_AND:
    case TOK_MUL:
    case KW_IF:
    case KW_WHILE:
    case KW_LOOP:
    case KW_FOR:
    case KW_MATCH:
        return 1;
    default:
        return 0;
    }
}

static int can_start_statement(spl_tok_type_t t) {
    switch (t) {
    case KW_IF:
    case KW_WHILE:
    case KW_LOOP:
    case KW_FOR:
    case KW_MATCH:
    case KW_RET:
    case KW_BREAK:
    case KW_CONTINUE:
    case KW_DEFER:
    case KW_VAR:
    case KW_CONST:
    case KW_TYPE:
    case KW_COMPTIME:
        return 1;
    default:
        return 0;
    }
}

static int is_builtin_type_kw(spl_tok_type_t t) {
    switch (t) {
    // case KW_I8:
    // case KW_U8:
    // case KW_I16:
    // case KW_U16:
    // case KW_I32:
    // case KW_U32:
    // case KW_I64:
    // case KW_U64:
    // case KW_F32:
    // case KW_F64:
    // case KW_ISIZE:
    // case KW_USIZE:
    case KW_BOOL:
    // case KW_VOID:
    // case KW_PTR:
    case KW_ANY:
        return 1;
    default:
        return 0;
    }
}

static spl_ast_node_ref_t parse_expr(spl_parser_t *p);
static spl_ast_node_ref_vec_t parse_expr_list(spl_parser_t *p);
static spl_ast_node_ref_t parse_block(spl_parser_t *p);
static spl_ast_node_ref_t parse_type_expr(spl_parser_t *p);
static spl_ast_node_ref_t parse_type_comptime_call(spl_parser_t *p);
static spl_ast_node_ref_t parse_statement(spl_parser_t *p);
static spl_ast_node_ref_t parse_container_declaration(spl_parser_t *p);
static spl_ast_node_ref_t parse_param_decl_impl(spl_parser_t *p);
static spl_ast_node_ref_t parse_pattern(spl_parser_t *p);
static spl_ast_node_ref_t parse_pattern_atom(spl_parser_t *p);
static spl_ast_node_ref_t parse_pattern_aggregate(spl_parser_t *p, const spl_tok_t *start);

static spl_ast_node_ref_t parse_cast(spl_parser_t *p);
static spl_ast_node_ref_t parse_prefix(spl_parser_t *p);
static spl_ast_node_ref_t parse_postfix(spl_parser_t *p);
static spl_ast_node_ref_t parse_primary(spl_parser_t *p);
static spl_ast_node_ref_vec_t parse_aggregate_fields(spl_parser_t *p);
static spl_ast_node_ref_t parse_array_literal(spl_parser_t *p);
static spl_ast_node_ref_t parse_comptime_call(spl_parser_t *p);
static spl_ast_node_ref_t parse_if_expr(spl_parser_t *p);
static spl_ast_node_ref_t parse_while_expr(spl_parser_t *p);
static spl_ast_node_ref_t parse_loop_expr(spl_parser_t *p);
static spl_ast_node_ref_t parse_for_expr(spl_parser_t *p);
static spl_ast_node_ref_t parse_match_expr(spl_parser_t *p);
static spl_ast_node_ref_t parse_ret_stmt(spl_parser_t *p);
static spl_ast_node_ref_t parse_break_stmt(spl_parser_t *p);
static spl_ast_node_ref_t parse_continue_stmt(spl_parser_t *p);
static spl_ast_node_ref_t parse_defer_stmt(spl_parser_t *p);
static spl_ast_node_ref_t parse_comptime_stmt(spl_parser_t *p);
static spl_ast_node_ref_t parse_label(spl_parser_t *p);

/* ---------- Pattern ---------- */

static spl_ast_node_ref_t parse_pattern_atom(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (!t)
        return 0;

    switch (t->type) {
    case KW_UNDERSCORE:
        advance(p);
        return new_node(p, SPL_AST_PATTERN_UNDERSCORE, t);

    case TOK_DOT: {
        advance(p);
        const spl_tok_t *nx = peek(p);
        if (nx && nx->type == TOK_L_BRACE)
            return parse_pattern_aggregate(p, t);

        if (!nx || nx->type != TOK_IDENT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, nx, "expected variant name after '.'");
            return 0;
        }
        advance(p);

        spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_DOT, t);
        spl_ast_node_t *pat = node_at(p->ast, ref);
        SET_STR_FIELD(p->ast, pat->pattern_dot.name, nx);
        pat->pattern_dot.sub_pattern = 0;

        if (peek(p) && peek(p)->type == TOK_L_PAREN) {
            advance(p);
            if (peek(p) && peek(p)->type != TOK_R_PAREN) {
                spl_ast_node_ref_t sub = parse_pattern(p);
                node_at(p->ast, ref)->pattern_dot.sub_pattern = sub;
            }
            expect(p, TOK_R_PAREN, "')' after variant payload");
        }
        return ref;
    }

    case TOK_L_PAREN: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_TUPLE, t);
        spl_ast_node_t *tuple = node_at(p->ast, ref);
        vec_init(tuple->pattern_tuple.patterns);

        if (peek(p) && peek(p)->type == TOK_R_PAREN) {
            advance(p);
            return ref;
        }

        spl_ast_node_ref_t inner = parse_pattern(p);
        expect(p, TOK_R_PAREN, "')' in tuple pattern");

        tuple = node_at(p->ast, ref);
        if (inner && node_at(p->ast, inner)->kind == SPL_AST_PATTERN_LIST) {
            spl_ast_node_t *inner_node = node_at(p->ast, inner);
            MOVE_VEC(tuple->pattern_tuple.patterns, inner_node->pattern_list.patterns);
        } else if (inner) {
            vec_push(tuple->pattern_tuple.patterns, inner);
        }
        return ref;
    }

    case TOK_INT_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_INT_LIT, t);
        node_at(p->ast, ref)->int_lit.bits = (uint64_t)parse_int_literal(t);
        return ref;
    }
    case TOK_FLOAT_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_FLOAT_LIT, t);
        node_at(p->ast, ref)->float_lit.bits = parse_float_literal(t);
        return ref;
    }
    case TOK_CHAR_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_CHAR_LIT, t);
        node_at(p->ast, ref)->char_lit.val = parse_char_literal(t);
        return ref;
    }
    case TOK_STRING_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_STRING_LIT, t);
        usize len = 0;
        const char *data = parse_string_literal(p, t, &len);
        spl_ast_node_t *node = node_at(p->ast, ref);
        node->string_lit.data = data;
        node->string_lit.len = len;
        return ref;
    }
    case KW_TRUE:
    case KW_FALSE: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_BOOL_LIT, t);
        node_at(p->ast, ref)->bool_lit.val = (t->type == KW_TRUE);
        return ref;
    }
    case KW_NULL:
        advance(p);
        return new_node(p, SPL_AST_EXPR_NULL_LIT, t);

    case TOK_IDENT: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_IDENT, t);
        SET_STR_FIELD(p->ast, node_at(p->ast, ref)->pattern_ident.name, t);
        return ref;
    }

    case TOK_AND: {
        /* `&name`：解包左值引用绑定。仅允许作用于绑定名。 */
        advance(p);
        const spl_tok_t *nx = peek(p);
        if (!nx || nx->type != TOK_IDENT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, nx, "expected binding name after '&'");
            return 0;
        }
        spl_ast_node_ref_t inner = parse_pattern_atom(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_REF, t);
        node_at(p->ast, ref)->pattern_ref.pat = inner;
        return ref;
    }

    default:
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unexpected token in pattern");
        return 0;
    }
}

static spl_ast_node_ref_t parse_pattern_aggregate(spl_parser_t *p, const spl_tok_t *start) {
    /* 已消费 '.'，当前应为 '{' */
    if (!expect(p, TOK_L_BRACE, "'{' after '.'"))
        return 0;

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_AGGREGATE, start);
    spl_ast_node_t *agg = node_at(p->ast, ref);
    vec_init(agg->pattern_aggregate.fields);

    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || t->type == TOK_R_BRACE || t->type == TOK_EOF)
            break;

        if (t->type != TOK_DOT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected '.' in aggregate pattern");
            break;
        }
        advance(p);

        const spl_tok_t *name = peek(p);
        if (!name || name->type != TOK_IDENT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, name, "expected field name");
            break;
        }
        advance(p);

        spl_ast_node_ref_t field = new_node(p, SPL_AST_PATTERN_FIELD, name);
        spl_ast_node_t *f = node_at(p->ast, field);
        SET_STR_FIELD(p->ast, f->pattern_field.name, name);
        f->pattern_field.pattern = 0;

        if (peek(p) && peek(p)->type == TOK_ASSIGN) {
            advance(p);
            spl_ast_node_ref_t sub = parse_pattern_atom(p);
            f = node_at(p->ast, field);
            f->pattern_field.pattern = sub;
        }

        agg = node_at(p->ast, ref);
        vec_push(agg->pattern_aggregate.fields, field);

        t = peek(p);
        if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON)) {
            advance(p);
            continue;
        }
        break;
    }

    expect(p, TOK_R_BRACE, "'}' in aggregate pattern");
    return ref;
}

static spl_ast_node_ref_t parse_pattern(spl_parser_t *p) {
    spl_ast_node_ref_vec_t atoms;
    vec_init(atoms);

    while (!p->failed) {
        spl_ast_node_ref_t atom = parse_pattern_atom(p);
        if (!atom)
            break;
        vec_push(atoms, atom);

        const spl_tok_t *t = peek(p);
        if (t && t->type == TOK_COMMA) {
            advance(p);
            continue;
        }
        break;
    }

    if (atoms.size == 0)
        return 0;
    if (atoms.size == 1) {
        spl_ast_node_ref_t r = atoms.data[0];
        vec_free(atoms);
        return r;
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_PATTERN_LIST, peek(p));
    node_at(p->ast, ref)->pattern_list.patterns = atoms;
    return ref;
}

/* ---------- 声明 ---------- */

static void parse_tag_list(spl_parser_t *p, spl_ast_node_ref_vec_t *out, int is_external,
                           int allow_at) {
    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || (t->type != TOK_AT && t->type != TOK_SHARP))
            return;
        if (!allow_at && t->type == TOK_AT)
            return;

        int is_at = (t->type == TOK_AT);
        advance(p);

        if (is_external) {
            t = peek(p);
            if (!t || t->type != TOK_NOT) {
                PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected '!' in external tag");
                return;
            }
            advance(p);
        }

        t = peek(p);
        if (!t || t->type != TOK_IDENT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected tag name");
            return;
        }
        advance(p);

        spl_ast_node_ref_t ref =
            new_node(p, is_external ? SPL_AST_EXTERNAL_TAG_ITEM : SPL_AST_TAG_ITEM, t);
        spl_ast_node_t *tag = node_at(p->ast, ref);
        tag->tag_item.is_at = is_at;
        tag->tag_item.is_external = is_external;
        SET_STR_FIELD(p->ast, tag->tag_item.name, t);

        t = peek(p);
        if (t && t->type == TOK_L_PAREN) {
            advance(p);
            spl_ast_node_ref_vec_t args = parse_expr_list(p);
            node_at(p->ast, ref)->tag_item.args = args;
            if (!expect(p, TOK_R_PAREN, "')' in tag args"))
                return;
        }
        vec_push(*out, ref);
    }
}

static void parse_param_list(spl_parser_t *p, spl_ast_node_ref_vec_t *out) {
    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t)
            break;

        if (t->type == TOK_R_PAREN) {
            break;
        } else if (t->type == TOK_AT || t->type == TOK_SHARP || t->type == TOK_IDENT) {
            spl_ast_node_ref_t pd = parse_param_decl_impl(p);
            if (pd)
                vec_push(*out, pd);
            if (peek(p) && peek(p)->type == TOK_COMMA) {
                advance(p);
                continue;
            }
            break;
        } else if (t->type == TOK_ELLIPSIS) {
            advance(p);
            spl_ast_node_ref_t pd = new_node(p, SPL_AST_PARAM_DECL, t);
            node_at(p->ast, pd)->param_decl.name = NULL;
            node_at(p->ast, pd)->param_decl.type_expr = 0;
            vec_push(*out, pd);
            if (peek(p) && peek(p)->type == TOK_COMMA)
                advance(p);
            break;
        } else {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t,
                        "unexpected token in parameter list");
            break;
        }
    }
}

static spl_ast_node_ref_t parse_param_decl_impl(spl_parser_t *p) {
    spl_ast_node_ref_vec_t attr_list;
    vec_init(attr_list);
    parse_tag_list(p, &attr_list, 0, 1);

    const spl_tok_t *name = peek(p);
    if (!name || (name->type != TOK_IDENT && name->type != KW_UNDERSCORE)) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, name, "expected parameter name or '_'");
        vec_free(attr_list);
        return 0;
    }
    advance(p);

    if (!expect(p, TOK_COLON, "':' in parameter declaration")) {
        vec_free(attr_list);
        return 0;
    }

    parse_tag_list(p, &attr_list, 0, 0);

    spl_ast_node_ref_t type_expr = parse_type_expr(p);
    spl_ast_node_ref_t ref = new_node(p, SPL_AST_PARAM_DECL, name);
    spl_ast_node_t *param = node_at(p->ast, ref);
    MOVE_VEC(param->param_decl.attr_list, attr_list);
    SET_STR_FIELD(p->ast, param->param_decl.name, name);
    param->param_decl.type_expr = type_expr;
    return ref;
}

static spl_ast_node_ref_t parse_fn_decl(spl_parser_t *p, spl_ast_node_ref_vec_t tag_list) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_FN)
        return 0;
    advance(p);

    const spl_tok_t *name = peek(p);
    if (!name || name->type != TOK_IDENT) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, name ? name : kw, "expected function name");
        vec_free(tag_list);
        return 0;
    }
    advance(p);

    if (!expect(p, TOK_L_PAREN, "'(' in function declaration")) {
        vec_free(tag_list);
        return 0;
    }

    spl_ast_node_ref_vec_t params;
    vec_init(params);
    parse_param_list(p, &params);
    if (!expect(p, TOK_R_PAREN, "')' in function declaration")) {
        vec_free(tag_list);
        vec_free(params);
        return 0;
    }

    spl_ast_node_ref_t ret_type = 0;
    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_COLON) {
        advance(p);
        ret_type = parse_type_expr(p);
        t = peek(p);
    }

    spl_ast_node_ref_t body = 0;
    if (t && t->type == TOK_L_BRACE) {
        body = parse_block(p);
    } else if (t && t->type == TOK_SEMICOLON) {
        advance(p);
    } else {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t,
                    "function declaration must end with ';' or block");
        vec_free(tag_list);
        vec_free(params);
        return 0;
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_FN_DECL, kw);
    spl_ast_node_t *fn = node_at(p->ast, ref);
    MOVE_VEC(fn->fn_decl.tag_list, tag_list);
    fn->fn_decl.is_comptime = 0;
    SET_STR_FIELD(p->ast, fn->fn_decl.name, name);
    fn->fn_decl.params = params;
    fn->fn_decl.ret_type = ret_type;
    fn->fn_decl.body = body;
    return ref;
}

static spl_ast_node_ref_t parse_type_decl(spl_parser_t *p, spl_ast_node_ref_vec_t tag_list) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_TYPE)
        return 0;
    advance(p);

    spl_ast_node_ref_t pattern = parse_pattern(p);
    if (!pattern) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, peek(p), "expected pattern after 'type'");
        vec_free(tag_list);
        return 0;
    }

    if (!expect(p, TOK_ASSIGN, "'=' in type declaration")) {
        vec_free(tag_list);
        return 0;
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_DECL, kw);
    spl_ast_node_t *td = node_at(p->ast, ref);
    MOVE_VEC(td->type_decl.attr_list, tag_list);
    td->type_decl.pattern = pattern;

    spl_ast_node_ref_t type_expr = parse_type_expr(p);
    td = node_at(p->ast, ref); /* parse_type_expr 可能 push node_buckets，重新取 */
    td->type_decl.type_expr = type_expr;

    const spl_tok_t *t = peek(p);
    if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON))
        advance(p);
    return ref;
}

static spl_ast_node_ref_t parse_var_const_decl(spl_parser_t *p, spl_ast_node_ref_vec_t tag_list,
                                               int is_const) {
    const spl_tok_t *kw = peek(p);
    if (!kw)
        return 0;
    if (is_const && kw->type != KW_CONST)
        return 0;
    if (!is_const && kw->type != KW_VAR)
        return 0;
    advance(p);

    spl_ast_node_ref_t pattern = parse_pattern(p);
    if (!pattern) {
        vec_free(tag_list);
        return 0;
    }

    spl_ast_node_ref_t type_expr = 0;
    spl_ast_node_ref_t init_expr = 0;
    const spl_tok_t *t = peek(p);

    if (t && t->type == TOK_COLON) {
        advance(p);
        type_expr = parse_type_expr(p);
        t = peek(p);
        if (t && t->type == TOK_ASSIGN) {
            advance(p);
            init_expr = parse_expr(p);
        }
    } else if (t && t->type == TOK_ASSIGN) {
        advance(p);
        init_expr = parse_expr(p);
    }

    spl_ast_node_ref_t ref = new_node(p, is_const ? SPL_AST_CONST_DECL : SPL_AST_VAR_DECL, kw);
    spl_ast_node_t *vc = node_at(p->ast, ref);
    MOVE_VEC(vc->var_const_decl.attr_list, tag_list);
    vc->var_const_decl.pattern = pattern;
    vc->var_const_decl.type = type_expr;
    vc->var_const_decl.init_expr = init_expr;

    t = peek(p);
    if (t && t->type == TOK_SEMICOLON)
        advance(p);
    return ref;
}

static spl_ast_node_ref_t parse_member_decl(spl_parser_t *p, spl_ast_node_ref_vec_t tag_list) {
    const spl_tok_t *name = peek(p);
    if (!name || name->type != TOK_IDENT)
        return 0;
    advance(p);

    spl_ast_node_ref_t type_expr = 0;
    spl_ast_node_ref_t init_expr = 0;
    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_COLON) {
        advance(p);
        parse_tag_list(p, &tag_list, 0, 0);
        type_expr = parse_type_expr(p);
        t = peek(p);
        if (t && t->type == TOK_ASSIGN) {
            advance(p);
            init_expr = parse_expr(p);
        }
    } else if (t && t->type == TOK_ASSIGN) {
        advance(p);
        init_expr = parse_expr(p);
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_MEMBER_DECL, name);
    spl_ast_node_t *md = node_at(p->ast, ref);
    MOVE_VEC(md->member_decl.attr_list, tag_list);
    SET_STR_FIELD(p->ast, md->member_decl.name, name);
    md->member_decl.type_expr = type_expr;
    md->member_decl.init_expr = init_expr;

    t = peek(p);
    if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON))
        advance(p);
    return ref;
}

static spl_ast_node_ref_t parse_comptime_decl(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_COMPTIME)
        return 0;
    advance(p);

    spl_ast_node_ref_t body = 0;
    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_L_BRACE)
        body = parse_block(p);
    else
        body = parse_expr(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_COMPTIME_DECL, kw);
    node_at(p->ast, ref)->comptime_decl.body = body;
    return ref;
}

static spl_ast_node_ref_t parse_container_declaration(spl_parser_t *p) {
    spl_ast_node_ref_vec_t tag_list;
    vec_init(tag_list);
    parse_tag_list(p, &tag_list, 0, 0);

    const spl_tok_t *t = peek(p);
    if (!t || t->type == TOK_EOF) {
        vec_free(tag_list);
        return 0;
    }

    switch (t->type) {
    case KW_FN:
        return parse_fn_decl(p, tag_list);
    case KW_TYPE:
        return parse_type_decl(p, tag_list);
    case KW_VAR:
        return parse_var_const_decl(p, tag_list, 0);
    case KW_CONST:
        return parse_var_const_decl(p, tag_list, 1);
    case TOK_IDENT:
        return parse_member_decl(p, tag_list);
    case KW_COMPTIME:
        vec_free(tag_list);
        return parse_comptime_decl(p);
    case TOK_L_BRACE: {
        spl_ast_node_ref_t block = parse_block(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_TOP_LEVEL_BLOCK, t);
        spl_ast_node_t *tb = node_at(p->ast, ref);
        MOVE_VEC(tb->top_level_block.tag_list, tag_list);
        tb->top_level_block.block = block;
        return ref;
    }
    default:
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unrecognized declaration");
        advance(p); /* 消费该 token，避免调用方在错误恢复时原地死循环 */
        vec_free(tag_list);
        return 0;
    }
}

/* ---------- 类型 ---------- */

static spl_ast_node_ref_t parse_type_base(spl_parser_t *p) {
    const spl_tok_t *bt = peek(p);
    if (!bt) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, bt, "expected type");
        return 0;
    }

    if (bt->type == KW_FN) {
        advance(p);
        if (!expect(p, TOK_L_PAREN, "'(' in function type"))
            return 0;

        spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_FN, bt);
        spl_ast_node_t *fn_type = node_at(p->ast, ref);
        fn_type->type_fn.is_comptime = 0;
        vec_init(fn_type->type_fn.params);

        while (!p->failed && peek(p) && peek(p)->type != TOK_R_PAREN) {
            spl_ast_node_ref_t pt = parse_type_expr(p);
            fn_type = node_at(p->ast, ref);
            vec_push(fn_type->type_fn.params, pt);
            if (peek(p) && peek(p)->type == TOK_COMMA) {
                advance(p);
                continue;
            }
            break;
        }

        if (!expect(p, TOK_R_PAREN, "')' in function type"))
            return ref;

        if (peek(p) && peek(p)->type == TOK_COLON) {
            advance(p);
            spl_ast_node_ref_t ret = parse_type_expr(p);
            node_at(p->ast, ref)->type_fn.ret_type = ret;
        }
        return ref;
    }

    if (bt->type == KW_STRUCT || bt->type == KW_UNION || bt->type == KW_ENUM ||
        bt->type == KW_SHAPE) {
        const char *kind_name = (bt->type == KW_STRUCT)  ? "struct"
                                : (bt->type == KW_UNION) ? "union"
                                : (bt->type == KW_ENUM)  ? "enum"
                                                         : "shape";
        advance(p);
        if (!expect(p, TOK_L_BRACE, "'{' in aggregate type"))
            return 0;

        spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_AGGREGATE, bt);
        spl_ast_node_t *agg = node_at(p->ast, ref);
        agg->type_aggregate.kind_name = kind_name;
        vec_init(agg->type_aggregate.members);

        while (!p->failed) {
            const spl_tok_t *t = peek(p);
            if (!t || t->type == TOK_EOF) {
                PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "aggregate type missing '}'");
                return ref;
            }
            if (t->type == TOK_R_BRACE) {
                advance(p);
                break;
            }

            spl_ast_node_ref_t member = parse_container_declaration(p);
            if (member) {
                agg = node_at(p->ast, ref);
                vec_push(agg->type_aggregate.members, member);
            }

            t = peek(p);
            if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON))
                advance(p);
        }
        return ref;
    }

    /* 内建类型 keyword + 普通标识符类型路径 */
    if (bt->type == TOK_IDENT || is_builtin_type_kw(bt->type)) {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_PATH, bt);
        spl_ast_node_t *tp = node_at(p->ast, ref);
        SET_STR_FIELD(p->ast, tp->type_path.name, bt);
        vec_init(tp->type_path.generic_args);
        return ref;
    }

    if (bt->type == TOK_AT || bt->type == TOK_SHARP)
        return parse_type_comptime_call(p);

    PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, bt, "unrecognized type");
    return 0;
}

static spl_ast_node_ref_t parse_type_comptime_call(spl_parser_t *p) {
    const spl_tok_t *start = peek(p);
    if (!start || (start->type != TOK_AT && start->type != TOK_SHARP))
        return 0;
    advance(p);

    const spl_tok_t *name = peek(p);
    if (!name || name->type != TOK_IDENT) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, name, "expected comptime name");
        return 0;
    }
    advance(p);

    spl_ast_node_ref_vec_t args;
    vec_init(args);

    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_L_PAREN) {
        advance(p);
        args = parse_expr_list(p);
        if (!expect(p, TOK_R_PAREN, "')' in comptime type")) {
            vec_free(args);
            return 0;
        }
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_COMPTIME_CALL, start);
    spl_ast_node_t *cc = node_at(p->ast, ref);
    SET_STR_FIELD(p->ast, cc->type_comptime_call.name, name);
    cc->type_comptime_call.args = args;
    return ref;
}

static spl_ast_node_ref_t parse_type_expr(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (!t) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected type");
        return 0;
    }

    if (t->type == TOK_MUL) {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_POINTER, t);
        spl_ast_node_ref_t pointee = parse_type_expr(p);
        node_at(p->ast, ref)->type_pointer.pointee = pointee;
        return ref;
    }

    if (t->type == TOK_L_BRACKET) {
        advance(p);
        bool has_len = false;
        isize len = 0;
        bool is_underscore = false;

        t = peek(p);
        if (t && t->type == TOK_INT_LITERAL) {
            len = parse_int_literal(t);
            has_len = true;
            advance(p);
        } else if (t && t->type == KW_UNDERSCORE) {
            has_len = true;
            is_underscore = true;
            advance(p);
        }

        if (!expect(p, TOK_R_BRACKET, "']' in array type"))
            return 0;

        spl_ast_node_ref_t elem_type = parse_type_expr(p);

        spl_ast_node_ref_t ref;
        if (has_len) {
            ref = new_node(p, SPL_AST_TYPE_ARRAY, t);
            spl_ast_node_t *arr = node_at(p->ast, ref);
            arr->type_array.has_len = true;
            arr->type_array.len = len;
            arr->type_array.is_underscore_len = is_underscore;
            arr->type_array.elem_type = elem_type;
        } else {
            ref = new_node(p, SPL_AST_TYPE_SLICE, t);
            node_at(p->ast, ref)->type_slice.elem_type = elem_type;
        }
        return ref;
    }

    if (t->type == TOK_L_PAREN) {
        advance(p);
        spl_ast_node_ref_vec_t types;
        vec_init(types);

        if (peek(p) && peek(p)->type == TOK_R_PAREN) {
            advance(p);
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_PAREN, t);
            node_at(p->ast, ref)->type_paren.types = types;
            return ref;
        }

        spl_ast_node_ref_t first = parse_type_expr(p);
        vec_push(types, first);

        while (peek(p) && peek(p)->type == TOK_COMMA) {
            advance(p);
            if (peek(p) && peek(p)->type == TOK_R_PAREN)
                break;
            spl_ast_node_ref_t next = parse_type_expr(p);
            vec_push(types, next);
        }

        if (!expect(p, TOK_R_PAREN, "')' in parenthesized type"))
            return 0;

        if (types.size == 1) {
            vec_free(types);
            return first;
        }

        spl_ast_node_ref_t ref = new_node(p, SPL_AST_TYPE_PAREN, t);
        node_at(p->ast, ref)->type_paren.types = types;
        return ref;
    }

    spl_ast_node_ref_t base = parse_type_base(p);
    if (p->failed || !base)
        return base;

    while (peek(p) && peek(p)->type == TOK_DOT) {
        const spl_tok_t *dot = peek(p);
        advance(p);
        const spl_tok_t *seg = peek(p);
        if (!seg || seg->type != TOK_IDENT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, seg ? seg : dot,
                        "type: expected identifier after '.'");
            return base;
        }
        advance(p);
        spl_ast_node_ref_t sel = new_node(p, SPL_AST_EXPR_FIELD, dot);
        node_at(p->ast, sel)->field.obj = base;
        SET_STR_FIELD(p->ast, node_at(p->ast, sel)->field.field, seg);
        base = sel;
    }
    return base;
}

/* ---------- 表达式 ---------- */

static spl_ast_node_ref_vec_t parse_expr_list(spl_parser_t *p) {
    spl_ast_node_ref_vec_t vec;
    vec_init(vec);
    if (p->failed)
        return vec;

    const spl_tok_t *t = peek(p);
    if (!t || !can_start_expr(t->type))
        return vec;

    vec_push(vec, parse_expr(p));
    while (!p->failed && peek(p) && peek(p)->type == TOK_COMMA) {
        advance(p);
        if (!peek(p) || !can_start_expr(peek(p)->type))
            break;
        vec_push(vec, parse_expr(p));
    }
    return vec;
}

static spl_ast_node_ref_vec_t parse_aggregate_fields(spl_parser_t *p) {
    spl_ast_node_ref_vec_t fields;
    vec_init(fields);

    if (!expect(p, TOK_L_BRACE, "'{' in aggregate literal"))
        return fields;

    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || t->type == TOK_R_BRACE || t->type == TOK_EOF)
            break;

        if (t->type != TOK_DOT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected '.' in aggregate field");
            break;
        }
        advance(p);

        t = peek(p);
        if (!t || t->type != TOK_IDENT) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected field name after '.'");
            break;
        }
        advance(p);

        spl_ast_node_ref_t item_ref = new_node(p, SPL_AST_STRUCT_INIT_ITEM, t);
        spl_ast_node_t *item = node_at(p->ast, item_ref);
        SET_STR_FIELD(p->ast, item->struct_init_item.name, t);
        item->struct_init_item.expr = 0;

        if (peek(p) && peek(p)->type == TOK_ASSIGN) {
            advance(p);
            spl_ast_node_ref_t expr_ref = parse_expr(p);
            item = node_at(p->ast, item_ref);
            item->struct_init_item.expr = expr_ref;
        }

        vec_push(fields, item_ref);

        t = peek(p);
        if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON)) {
            advance(p);
            continue;
        }
        break;
    }

    expect(p, TOK_R_BRACE, "'}' in aggregate literal");
    return fields;
}

typedef struct {
    int prec;
    char assoc;
} op_info_t;

static op_info_t binary_op_info[] = {
#define X(name, prec, assoc, str) {prec, assoc},
    SPL_BINARY_OP_TABLE
#undef X
};

static spl_binary_op_t token_to_binary_op(spl_tok_type_t tt) {
    switch (tt) {
    case TOK_ASSIGN:
        return SPL_OP_ASSIGN;
    case TOK_ASSIGN_ADD:
        return SPL_OP_ASSIGN_ADD;
    case TOK_ASSIGN_SUB:
        return SPL_OP_ASSIGN_SUB;
    case TOK_ASSIGN_MUL:
        return SPL_OP_ASSIGN_MUL;
    case TOK_ASSIGN_DIV:
        return SPL_OP_ASSIGN_DIV;
    case TOK_ASSIGN_MOD:
        return SPL_OP_ASSIGN_MOD;
    case TOK_ASSIGN_AND:
        return SPL_OP_ASSIGN_AND;
    case TOK_ASSIGN_OR:
        return SPL_OP_ASSIGN_OR;
    case TOK_ASSIGN_XOR:
        return SPL_OP_ASSIGN_XOR;
    case TOK_ASSIGN_L_SH:
        return SPL_OP_ASSIGN_LSHIFT;
    case TOK_ASSIGN_R_SH:
        return SPL_OP_ASSIGN_RSHIFT;
    case TOK_OR_OR:
        return SPL_OP_BOOL_OR;
    case TOK_AND_AND:
        return SPL_OP_BOOL_AND;
    case TOK_OR:
        return SPL_OP_BIT_OR;
    case TOK_XOR:
        return SPL_OP_BIT_XOR;
    case TOK_AND:
        return SPL_OP_BIT_AND;
    case TOK_EQ:
        return SPL_OP_CMP_EQ;
    case TOK_NEQ:
        return SPL_OP_CMP_NE;
    case TOK_LE:
        return SPL_OP_CMP_LE;
    case TOK_GE:
        return SPL_OP_CMP_GE;
    case TOK_LT:
        return SPL_OP_CMP_LT;
    case TOK_GT:
        return SPL_OP_CMP_GT;
    case TOK_LEFT_ARROW:
        return SPL_OP_ARROW_LEFT;
    case TOK_RIGHT_ARROW:
        return SPL_OP_ARROW_RIGHT;
    case TOK_FAT_ARROW_BOTH:
        return SPL_OP_ARROW_FAT_BOTH;
    case TOK_ARROW_BOTH:
        return SPL_OP_ARROW_THIN_BOTH;
    case TOK_RIGHT_FAT_ARROW:
        return SPL_OP_ARROW_FAT_RIGHT;
    case TOK_RANGE:
        return SPL_OP_RANGE;
    case TOK_L_SH:
        return SPL_OP_LSHIFT;
    case TOK_R_SH:
        return SPL_OP_RSHIFT;
    case TOK_ADD:
        return SPL_OP_ADD;
    case TOK_SUB:
        return SPL_OP_SUB;
    case TOK_MUL:
        return SPL_OP_MUL;
    case TOK_DIV:
        return SPL_OP_DIV;
    case TOK_MOD:
        return SPL_OP_MOD;
    default:
        return (spl_binary_op_t)-1;
    }
}

static spl_ast_node_ref_t mk_bin(spl_parser_t *p, const spl_tok_t *loc, spl_binary_op_t op,
                                 spl_ast_node_ref_t left, spl_ast_node_ref_t right) {
    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_BINARY, loc);
    spl_ast_node_t *node = node_at(p->ast, ref);
    node->binary.op = op;
    node->binary.left = left;
    node->binary.right = right;
    return ref;
}

static spl_ast_node_ref_t mk_unary(spl_parser_t *p, const spl_tok_t *loc, spl_unary_op_t op,
                                   spl_ast_node_ref_t operand) {
    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_UNARY, loc);
    spl_ast_node_t *node = node_at(p->ast, ref);
    node->unary.op = op;
    node->unary.operand = operand;
    return ref;
}

static spl_ast_node_ref_t parse_expr_prec(spl_parser_t *p, int min_prec) {
    spl_ast_node_ref_t left = parse_cast(p);
    if (p->failed)
        return left;

    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t)
            break;
        spl_binary_op_t op = token_to_binary_op(t->type);
        if (op == (spl_binary_op_t)-1)
            break;

        op_info_t info = binary_op_info[op];
        if (info.prec < min_prec)
            break;

        advance(p);

        if (op == SPL_OP_RANGE) {
            spl_ast_node_ref_t right = 0;
            if (peek(p) && can_start_expr(peek(p)->type))
                right = parse_expr_prec(p, info.prec + 1);
            left = mk_bin(p, t, op, left, right);
            continue;
        }

        int next_min = (info.assoc == 'R') ? info.prec : info.prec + 1;
        spl_ast_node_ref_t right = parse_expr_prec(p, next_min);
        left = mk_bin(p, t, op, left, right);
    }

    return left;
}

static spl_ast_node_ref_t parse_expr(spl_parser_t *p) { return parse_expr_prec(p, 1); }

static spl_ast_node_ref_t parse_cast(spl_parser_t *p) {
    spl_ast_node_ref_t expr = parse_prefix(p);
    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || t->type != KW_AS)
            break;
        advance(p);
        spl_ast_node_ref_t type = parse_type_expr(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_CAST, t);
        node_at(p->ast, ref)->cast.expr = expr;
        node_at(p->ast, ref)->cast.type = type;
        expr = ref;
    }
    return expr;
}

static spl_ast_node_ref_t parse_prefix(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (!t)
        return 0;

    if (t->type == TOK_DOLLAR) {
        spl_ast_node_ref_t label = parse_label(p);
        const spl_tok_t *kw = peek(p);
        spl_ast_node_ref_t ref = 0;
        if (kw && kw->type == KW_WHILE)
            ref = parse_while_expr(p);
        else if (kw && kw->type == KW_LOOP)
            ref = parse_loop_expr(p);
        else if (kw && kw->type == KW_FOR)
            ref = parse_for_expr(p);
        else {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, kw, "expected while/loop/for after label");
            return 0;
        }
        if (!ref)
            return 0;

        spl_ast_node_t *n = node_at(p->ast, ref);
        switch (n->kind) {
        case SPL_AST_EXPR_WHILE:
            n->while_expr.label = label;
            break;
        case SPL_AST_EXPR_LOOP:
            n->loop_expr.label = label;
            break;
        case SPL_AST_EXPR_FOR:
            n->for_expr.label = label;
            break;
        default:
            break;
        }
        return ref;
    }

    spl_unary_op_t uop;
    switch (t->type) {
    case TOK_SUB:
        uop = SPL_UNARY_OP_MINUS;
        break;
    case TOK_NOT:
        uop = SPL_UNARY_OP_NOT;
        break;
    case TOK_BIT_NOT:
        uop = SPL_UNARY_OP_BIT_NOT;
        break;
    case TOK_AND:
        uop = SPL_UNARY_OP_ADDRESS;
        break;
    default:
        return parse_postfix(p);
    }
    advance(p);
    spl_ast_node_ref_t operand = parse_prefix(p);
    return mk_unary(p, t, uop, operand);
}

static spl_ast_node_ref_t parse_postfix(spl_parser_t *p) {
    spl_ast_node_ref_t expr = parse_primary(p);
    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t)
            break;

        if (t->type == TOK_L_PAREN) {
            advance(p);
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_CALL, t);
            node_at(p->ast, ref)->call.callee = expr;

            spl_ast_node_ref_vec_t args = parse_expr_list(p);
            node_at(p->ast, ref)->call.args = args;

            if (!expect(p, TOK_R_PAREN, "')' in call"))
                return expr;
            expr = ref;
        } else if (t->type == TOK_DOT) {
            advance(p);
            const spl_tok_t *next = peek(p);
            if (!next)
                break;
            if (next->type == TOK_IDENT) {
                advance(p);
                spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_FIELD, t);
                node_at(p->ast, ref)->field.obj = expr;
                SET_STR_FIELD(p->ast, node_at(p->ast, ref)->field.field, next);
                expr = ref;
            } else if (next->type == TOK_MUL) {
                advance(p);
                expr = mk_unary(p, t, SPL_UNARY_OP_DEREF, expr);
            } else {
                PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, next,
                            "expected identifier or '*' after '.'");
                break;
            }
        } else if (t->type == TOK_L_BRACKET) {
            advance(p);
            int range_prec = binary_op_info[SPL_OP_RANGE].prec;
            spl_ast_node_ref_t begin = parse_expr_prec(p, range_prec + 1);
            if (peek(p) && peek(p)->type == TOK_RANGE) {
                advance(p);
                spl_ast_node_ref_t end = 0;
                if (peek(p) && peek(p)->type != TOK_R_BRACKET)
                    end = parse_expr(p);
                if (!expect(p, TOK_R_BRACKET, "']' in slice"))
                    return expr;
                spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_SLICE, t);
                node_at(p->ast, ref)->slice.obj = expr;
                node_at(p->ast, ref)->slice.begin = begin;
                node_at(p->ast, ref)->slice.end = end;
                expr = ref;
            } else {
                if (!expect(p, TOK_R_BRACKET, "']' in index"))
                    return expr;
                spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_INDEX, t);
                node_at(p->ast, ref)->index.obj = expr;
                node_at(p->ast, ref)->index.index = begin;
                expr = ref;
            }
        } else {
            break;
        }
    }
    return expr;
}

static spl_ast_node_ref_t parse_variant_construct(spl_parser_t *p, const spl_tok_t *dot) {
    /* 已消费 '.'，当前 token 是 IDENT */
    const spl_tok_t *name = advance(p);
    spl_ast_node_ref_vec_t fields;
    vec_init(fields);

    spl_ast_node_ref_t field = new_node(p, SPL_AST_STRUCT_INIT_ITEM, name);
    node_at(p->ast, field)->struct_init_item.name = intern_string(p->ast, name->lexeme, name->len);
    node_at(p->ast, field)->struct_init_item.expr = 0;

    if (peek(p) && peek(p)->type == TOK_L_PAREN) {
        advance(p);
        spl_ast_node_ref_vec_t args;
        vec_init(args);
        if (peek(p) && peek(p)->type != TOK_R_PAREN)
            args = parse_expr_list(p);
        expect(p, TOK_R_PAREN, "')' after variant payload");

        spl_ast_node_ref_t expr = 0;
        if (args.size == 1) {
            expr = args.data[0];
        } else {
            expr = new_node(p, SPL_AST_EXPR_TUPLE, name);
            node_at(p->ast, expr)->tuple.elems = args;
            vec_init(args);
        }
        vec_free(args);
        node_at(p->ast, field)->struct_init_item.expr = expr;
    }

    vec_push(fields, field);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_AGGREGATE_LIT, dot);
    spl_ast_node_t *agg = node_at(p->ast, ref);
    agg->aggregate_literal.name = NULL;
    agg->aggregate_literal.fields = fields;
    return ref;
}

static spl_ast_node_ref_t parse_primary(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (!t) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unexpected end of expression");
        return 0;
    }

    switch (t->type) {
    case TOK_INT_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_INT_LIT, t);
        node_at(p->ast, ref)->int_lit.bits = (uint64_t)parse_int_literal(t);
        return ref;
    }
    case TOK_FLOAT_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_FLOAT_LIT, t);
        node_at(p->ast, ref)->float_lit.bits = parse_float_literal(t);
        return ref;
    }
    case TOK_CHAR_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_CHAR_LIT, t);
        node_at(p->ast, ref)->char_lit.val = parse_char_literal(t);
        return ref;
    }
    case TOK_STRING_LITERAL: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_STRING_LIT, t);
        usize len = 0;
        const char *data = parse_string_literal(p, t, &len);
        spl_ast_node_t *node = node_at(p->ast, ref);
        node->string_lit.data = data;
        node->string_lit.len = len;
        return ref;
    }
    case KW_TRUE:
    case KW_FALSE: {
        advance(p);
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_BOOL_LIT, t);
        node_at(p->ast, ref)->bool_lit.val = (t->type == KW_TRUE);
        return ref;
    }
    case KW_NULL:
        advance(p);
        return new_node(p, SPL_AST_EXPR_NULL_LIT, t);
    case KW_UNDEFINED:
        advance(p);
        return new_node(p, SPL_AST_EXPR_UNDEFINED_LIT, t);

    case TOK_IDENT: {
        advance(p);
        if (peek(p) && peek(p)->type == TOK_L_BRACE && !p->stop_agg) {
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_AGGREGATE_LIT, t);
            spl_ast_node_t *agg = node_at(p->ast, ref);
            agg->aggregate_literal.name = intern_string(p->ast, t->lexeme, t->len);

            spl_ast_node_ref_vec_t fields = parse_aggregate_fields(p);
            node_at(p->ast, ref)->aggregate_literal.fields = fields;
            return ref;
        }
        spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_IDENT, t);
        node_at(p->ast, ref)->ident.name = intern_string(p->ast, t->lexeme, t->len);
        return ref;
    }

    case TOK_DOT: {
        advance(p);
        const spl_tok_t *nx = peek(p);
        if (!nx) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unexpected '.'");
            return 0;
        }
        if (nx->type == TOK_L_BRACE && !p->stop_agg) {
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_AGGREGATE_LIT, t);
            node_at(p->ast, ref)->aggregate_literal.name = NULL;
            spl_ast_node_ref_vec_t fields = parse_aggregate_fields(p);
            node_at(p->ast, ref)->aggregate_literal.fields = fields;
            return ref;
        } else if (nx->type == TOK_L_BRACKET) {
            advance(p);
            spl_ast_node_ref_vec_t elems = parse_expr_list(p);
            if (!expect(p, TOK_R_BRACKET, "']' in array literal"))
                return 0;
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_ARRAY_LIT, t);
            spl_ast_node_t *arr = node_at(p->ast, ref);
            arr->array_literal.elems = elems;
            arr->array_literal.elem_type = 0;
            return ref;
        } else if (nx->type == TOK_IDENT) {
            return parse_variant_construct(p, t);
        } else {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, nx,
                        "expected '{', '[' or identifier after '.'");
            return 0;
        }
    }

    case TOK_L_BRACKET:
        return parse_array_literal(p);
    case TOK_L_BRACE:
        return parse_block(p);
    case TOK_AT:
    case TOK_SHARP:
        return parse_comptime_call(p);

    case TOK_L_PAREN: {
        advance(p);
        spl_ast_node_ref_vec_t elems;
        vec_init(elems);

        if (peek(p) && peek(p)->type == TOK_R_PAREN) {
            advance(p);
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_TUPLE, t);
            node_at(p->ast, ref)->tuple.elems = elems;
            return ref;
        }

        spl_ast_node_ref_t first = parse_expr(p);
        if (peek(p) && peek(p)->type == TOK_COMMA) {
            vec_push(elems, first);
            while (peek(p) && peek(p)->type == TOK_COMMA) {
                advance(p);
                if (peek(p) && peek(p)->type == TOK_R_PAREN)
                    break;
                vec_push(elems, parse_expr(p));
            }
            if (!expect(p, TOK_R_PAREN, "')' in tuple literal"))
                return 0;
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_TUPLE, t);
            node_at(p->ast, ref)->tuple.elems = elems;
            return ref;
        } else {
            if (!expect(p, TOK_R_PAREN, "')' in paren expression"))
                return 0;
            vec_free(elems);
            return first;
        }
    }
    case KW_IF:
        return parse_if_expr(p);
    case KW_WHILE:
        return parse_while_expr(p);
    case KW_LOOP:
        return parse_loop_expr(p);
    case KW_FOR:
        return parse_for_expr(p);
    case KW_MATCH:
        return parse_match_expr(p);
    default:
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unrecognized expression");
        return 0;
    }
}

static spl_ast_node_ref_t parse_array_literal(spl_parser_t *p) {
    const spl_tok_t *start = peek(p);
    if (!start || start->type != TOK_L_BRACKET)
        return 0;
    advance(p);

    bool has_len = false;
    isize len = 0;
    bool is_underscore = false;

    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_INT_LITERAL) {
        len = parse_int_literal(t);
        has_len = true;
        advance(p);
    } else if (t && t->type == KW_UNDERSCORE) {
        has_len = true;
        is_underscore = true;
        advance(p);
    }

    if (!expect(p, TOK_R_BRACKET, "']' in array literal"))
        return 0;

    spl_ast_node_ref_t elem_type = parse_type_expr(p);
    if (!expect(p, TOK_L_BRACKET, "'[' in array literal"))
        return 0;

    spl_ast_node_ref_vec_t elems = parse_expr_list(p);
    if (!expect(p, TOK_R_BRACKET, "']' in array literal"))
        return 0;

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_ARRAY_LIT, start);
    spl_ast_node_t *arr = node_at(p->ast, ref);
    arr->array_literal.has_len = has_len;
    arr->array_literal.len = (usize)len;
    arr->array_literal.is_underscore_len = is_underscore;
    arr->array_literal.elem_type = elem_type;
    arr->array_literal.elems = elems;
    return ref;
}

static spl_ast_node_ref_t parse_comptime_call(spl_parser_t *p) {
    const spl_tok_t *start = peek(p);
    if (!start || (start->type != TOK_AT && start->type != TOK_SHARP))
        return 0;
    advance(p);

    const spl_tok_t *name = peek(p);
    if (!name || name->type != TOK_IDENT) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, name, "expected comptime name");
        return 0;
    }
    advance(p);

    spl_ast_node_ref_vec_t args;
    vec_init(args);

    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_L_PAREN) {
        advance(p);
        args = parse_expr_list(p);
        if (!expect(p, TOK_R_PAREN, "')' in comptime call")) {
            vec_free(args);
            return 0;
        }
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_COMPTIME_CALL, start);
    spl_ast_node_t *cc = node_at(p->ast, ref);
    SET_STR_FIELD(p->ast, cc->comptime_call.name, name);
    cc->comptime_call.args = args;
    return ref;
}

static spl_ast_node_ref_t parse_label(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (!t || t->type != TOK_DOLLAR)
        return 0;
    advance(p);
    const spl_tok_t *name = peek(p);
    if (!name || name->type != TOK_IDENT) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, name, "expected identifier after '$'");
        return 0;
    }
    advance(p);
    spl_ast_node_ref_t ref = new_node(p, SPL_AST_LABEL, t);
    SET_STR_FIELD(p->ast, node_at(p->ast, ref)->label.name, name);
    return ref;
}

static spl_ast_node_ref_t parse_if_expr(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_IF)
        return 0;
    advance(p);

    int is_ifvar = 0;
    spl_ast_node_ref_t var_decl = 0;

    const spl_tok_t *t = peek(p);
    if (t && t->type == KW_VAR) {
        advance(p);
        is_ifvar = 1;

        spl_ast_node_ref_t pattern = parse_pattern(p);
        if (!pattern)
            return 0;

        spl_ast_node_ref_t type_expr = 0;
        spl_ast_node_ref_t init_expr = 0;
        t = peek(p);
        if (t && t->type == TOK_COLON) {
            advance(p);
            type_expr = parse_type_expr(p);
            t = peek(p);
            if (t && t->type == TOK_ASSIGN) {
                advance(p);
                p->stop_agg++;
                init_expr = parse_expr(p);
                p->stop_agg--;
            } else {
                PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "expected '=' in if var");
                return 0;
            }
        } else if (t && t->type == TOK_ASSIGN) {
            advance(p);
            p->stop_agg++;
            init_expr = parse_expr(p);
            p->stop_agg--;
        } else {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t,
                        "expected type annotation or '=' in if var");
            return 0;
        }

        var_decl = new_node(p, SPL_AST_VAR_DECL, kw);
        spl_ast_node_t *vd = node_at(p->ast, var_decl);
        vd->var_const_decl.pattern = pattern;
        vd->var_const_decl.type = type_expr;
        vd->var_const_decl.init_expr = init_expr;
    } else {
        p->stop_agg++;
        spl_ast_node_ref_t cond = parse_expr(p);
        p->stop_agg--;
        if (!cond)
            return 0;
        var_decl = cond;
    }

    spl_ast_node_ref_t then_block = parse_block(p);
    if (!then_block)
        return 0;

    spl_ast_node_ref_t else_branch = 0;
    t = peek(p);
    if (t && t->type == KW_ELSE) {
        advance(p);
        t = peek(p);
        if (t && t->type == KW_IF)
            else_branch = parse_if_expr(p);
        else
            else_branch = parse_block(p);
    }

    spl_ast_node_ref_t ref;
    if (is_ifvar) {
        ref = new_node(p, SPL_AST_EXPR_IFVAR, kw);
        node_at(p->ast, ref)->ifvar_expr.var_decl = var_decl;
        node_at(p->ast, ref)->ifvar_expr.then_block = then_block;
        node_at(p->ast, ref)->ifvar_expr.else_branch = else_branch;
    } else {
        ref = new_node(p, SPL_AST_EXPR_IF, kw);
        node_at(p->ast, ref)->if_expr.cond = var_decl;
        node_at(p->ast, ref)->if_expr.then_block = then_block;
        node_at(p->ast, ref)->if_expr.else_branch = else_branch;
    }
    return ref;
}

static spl_ast_node_ref_t parse_while_expr(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_WHILE)
        return 0;
    advance(p);

    p->stop_agg++;
    spl_ast_node_ref_t cond = parse_expr(p);
    p->stop_agg--;
    if (!cond)
        return 0;

    spl_ast_node_ref_t body = parse_block(p);
    if (!body)
        return 0;

    spl_ast_node_ref_t else_branch = 0;
    if (peek(p) && peek(p)->type == KW_ELSE) {
        advance(p);
        if (peek(p) && peek(p)->type == TOK_L_BRACE)
            else_branch = parse_block(p);
        else
            else_branch = parse_expr(p);
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_WHILE, kw);
    node_at(p->ast, ref)->while_expr.label = 0;
    node_at(p->ast, ref)->while_expr.cond = cond;
    node_at(p->ast, ref)->while_expr.body = body;
    node_at(p->ast, ref)->while_expr.else_branch = else_branch;
    return ref;
}

static spl_ast_node_ref_t parse_loop_expr(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_LOOP)
        return 0;
    advance(p);

    spl_ast_node_ref_t body = parse_block(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_LOOP, kw);
    node_at(p->ast, ref)->loop_expr.label = 0;
    node_at(p->ast, ref)->loop_expr.body = body;
    return ref;
}

static spl_ast_node_ref_t parse_for_expr(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_FOR)
        return 0;
    advance(p);

    spl_ast_node_ref_t pattern = parse_pattern(p);
    if (!pattern) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, peek(p), "expected pattern in for");
        return 0;
    }

    if (!expect(p, TOK_COLON, "':' after for pattern"))
        return 0;

    spl_ast_node_ref_vec_t iter_exprs;
    vec_init(iter_exprs);
    p->stop_agg++;
    vec_push(iter_exprs, parse_expr(p));
    while (peek(p) && peek(p)->type == TOK_COMMA) {
        advance(p);
        vec_push(iter_exprs, parse_expr(p));
    }
    p->stop_agg--;

    spl_ast_node_ref_t body = parse_block(p);
    if (!body) {
        vec_free(iter_exprs);
        return 0;
    }

    spl_ast_node_ref_t else_branch = 0;
    if (peek(p) && peek(p)->type == KW_ELSE) {
        advance(p);
        if (peek(p) && peek(p)->type == TOK_L_BRACE)
            else_branch = parse_block(p);
        else
            else_branch = parse_expr(p);
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_FOR, kw);
    spl_ast_node_t *fe = node_at(p->ast, ref);
    fe->for_expr.label = 0;
    fe->for_expr.iter_exprs = iter_exprs;
    fe->for_expr.pattern = pattern;
    fe->for_expr.body = body;
    fe->for_expr.else_branch = else_branch;
    return ref;
}

static spl_ast_node_ref_t parse_match_expr(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_MATCH)
        return 0;
    advance(p);

    p->stop_agg++;
    spl_ast_node_ref_t matched_expr = parse_expr(p);
    p->stop_agg--;

    if (!expect(p, TOK_L_BRACE, "'{' in match"))
        return 0;

    spl_ast_node_ref_vec_t patterns, bodies;
    vec_init(patterns);
    vec_init(bodies);

    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || t->type == TOK_R_BRACE || t->type == TOK_EOF)
            break;

        spl_ast_node_ref_t pat = parse_pattern(p);
        if (!pat)
            break;

        if (!expect(p, TOK_RIGHT_FAT_ARROW, "'=>' in match arm"))
            break;

        spl_ast_node_ref_t body = parse_block(p);

        vec_push(patterns, pat);
        vec_push(bodies, body);

        if (peek(p) && peek(p)->type == TOK_COMMA)
            advance(p);
    }

    if (!expect(p, TOK_R_BRACE, "'}' in match"))
        return 0;

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_MATCH, kw);
    spl_ast_node_t *me = node_at(p->ast, ref);
    me->match_expr.matched_expr = matched_expr;
    vec_init(me->match_expr.arms);
    for (usize i = 0; i < patterns.size; i++) {
        spl_ast_node_ref_t arm = new_node(p, SPL_AST_MATCH_ARM, NULL);
        spl_ast_node_t *arm_node = node_at(p->ast, arm);
        arm_node->match_arm.pattern = patterns.data[i];
        arm_node->match_arm.body = bodies.data[i];

        me = node_at(p->ast, ref);
        vec_push(me->match_expr.arms, arm);
    }
    vec_free(patterns);
    vec_free(bodies);
    return ref;
}

static spl_ast_node_ref_t parse_ret_stmt(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_RET)
        return 0;
    advance(p);

    spl_ast_node_ref_t expr = 0;
    const spl_tok_t *t = peek(p);
    if (t && can_start_expr(t->type))
        expr = parse_expr(p);

    t = peek(p);
    if (t && t->type == TOK_SEMICOLON)
        advance(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_RET, kw);
    node_at(p->ast, ref)->statement_ret.expr = expr;
    return ref;
}

static spl_ast_node_ref_t parse_break_stmt(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_BREAK)
        return 0;
    advance(p);

    spl_ast_node_ref_t label = parse_label(p);
    spl_ast_node_ref_t expr = 0;
    const spl_tok_t *t = peek(p);
    if (t && can_start_expr(t->type))
        expr = parse_expr(p);

    t = peek(p);
    if (t && t->type == TOK_SEMICOLON)
        advance(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_BREAK, kw);
    node_at(p->ast, ref)->statement_break.label = label;
    node_at(p->ast, ref)->statement_break.expr = expr;
    return ref;
}

static spl_ast_node_ref_t parse_continue_stmt(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_CONTINUE)
        return 0;
    advance(p);

    spl_ast_node_ref_t label = parse_label(p);

    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_SEMICOLON)
        advance(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_CONTINUE, kw);
    node_at(p->ast, ref)->statement_continue.label = label;
    return ref;
}

static spl_ast_node_ref_t parse_defer_stmt(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_DEFER)
        return 0;
    advance(p);

    spl_ast_node_ref_t body = 0;
    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_L_BRACE) {
        body = parse_block(p);
    } else if (t && can_start_statement(t->type)) {
        body = parse_statement(p);
    } else {
        body = parse_expr(p);
        t = peek(p);
        if (t && t->type == TOK_SEMICOLON)
            advance(p);
    }

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_DEFER, kw);
    node_at(p->ast, ref)->statement_defer.body = body;
    return ref;
}

static spl_ast_node_ref_t parse_comptime_stmt(spl_parser_t *p) {
    const spl_tok_t *kw = peek(p);
    if (!kw || kw->type != KW_COMPTIME)
        return 0;
    advance(p);

    spl_ast_node_ref_t body = 0;
    const spl_tok_t *t = peek(p);
    if (t && t->type == TOK_L_BRACE)
        body = parse_block(p);
    else
        body = parse_expr(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_COMPTIME, kw);
    node_at(p->ast, ref)->statement_comptime.body = body;
    return ref;
}

static spl_ast_node_ref_t parse_statement(spl_parser_t *p) {
    const spl_tok_t *t = peek(p);
    if (!t)
        return 0;

    switch (t->type) {
    case KW_RET:
        return parse_ret_stmt(p);
    case KW_BREAK:
        return parse_break_stmt(p);
    case KW_CONTINUE:
        return parse_continue_stmt(p);
    case KW_DEFER:
        return parse_defer_stmt(p);
    case KW_COMPTIME:
        return parse_comptime_stmt(p);
    case KW_VAR:
    case KW_CONST:
    case KW_TYPE: {
        spl_ast_node_ref_vec_t tag_list;
        vec_init(tag_list);
        parse_tag_list(p, &tag_list, 0, 0);

        spl_ast_node_ref_t decl;
        if (t->type == KW_VAR)
            decl = parse_var_const_decl(p, tag_list, 0);
        else if (t->type == KW_CONST)
            decl = parse_var_const_decl(p, tag_list, 1);
        else
            decl = parse_type_decl(p, tag_list);
        if (!decl)
            return 0;

        spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_DECL, t);
        node_at(p->ast, ref)->statement_decl.decl = decl;
        return ref;
    }
    default: {
        if (can_start_expr(t->type)) {
            spl_ast_node_ref_t expr = parse_expr(p);
            if (!expr)
                return 0;
            spl_ast_node_ref_t ref = new_node(p, SPL_AST_STATEMENT_EXPR, t);
            node_at(p->ast, ref)->statement_expr.expr = expr;
            return ref;
        }
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unrecognized statement");
        return 0;
    }
    }
}

static spl_ast_node_ref_t parse_block(spl_parser_t *p) {
    const spl_tok_t *start = peek(p);
    if (!start || start->type != TOK_L_BRACE) {
        PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, start, "expected '{'");
        return 0;
    }
    advance(p);

    spl_ast_node_ref_t ref = new_node(p, SPL_AST_EXPR_BLOCK, start);
    spl_ast_node_t *block = node_at(p->ast, ref);
    vec_init(block->block.stmts);
    block->block.tail_expr = 0;

    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || t->type == TOK_EOF) {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t, "block missing '}'");
            return ref;
        }
        if (t->type == TOK_R_BRACE) {
            advance(p);
            break;
        }

        if (can_start_statement(t->type)) {
            spl_ast_node_ref_t stmt = parse_statement(p);
            block = node_at(p->ast, ref);
            if (stmt)
                vec_push(block->block.stmts, stmt);
            else
                break;
        } else if (can_start_expr(t->type)) {
            spl_ast_node_ref_t expr = parse_expr(p);
            if (!expr)
                break;
            block = node_at(p->ast, ref);
            t = peek(p);
            if (t && t->type == TOK_SEMICOLON) {
                advance(p);
                vec_push(block->block.stmts, expr);
            } else if (t && t->type == TOK_R_BRACE) {
                if (block->block.tail_expr != 0) {
                    PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t,
                                "only one tail expression allowed");
                }
                block->block.tail_expr = expr;
            } else {
                spl_ast_node_kind_t k = node_at(p->ast, expr)->kind;
                bool block_like =
                    (k == SPL_AST_EXPR_BLOCK || k == SPL_AST_EXPR_IF || k == SPL_AST_EXPR_IFVAR ||
                     k == SPL_AST_EXPR_WHILE || k == SPL_AST_EXPR_LOOP || k == SPL_AST_EXPR_FOR ||
                     k == SPL_AST_EXPR_MATCH);
                if (block_like)
                    vec_push(block->block.stmts, expr);
                else {
                    PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_EXPECTED, t,
                                "expected ';' or '}' after expression");
                    break;
                }
            }
        } else {
            PARSE_ERROR(p, SPL_DIAG_KIND_PARSE_UNRECOGNIZED, t, "unrecognized token in block");
            break;
        }
    }

    return ref;
}

/* ---------- 入口 ---------- */

void spl_parser_init(spl_parser_t *parser) {
    parser->ast = NULL;
    parser->diag = NULL;
    parser->pos = 0;
    parser->failed = 0;
    parser->stop_agg = 0;
    parser->error_count = 0;
}

void spl_parser_drop(spl_parser_t *parser) { (void)parser; }

static void skip_to_sync(spl_parser_t *p) {
    while (!p->failed) {
        const spl_tok_t *t = peek(p);
        if (!t || t->type == TOK_EOF)
            return;
        if (t->type == TOK_SEMICOLON || t->type == TOK_R_BRACE) {
            advance(p);
            return;
        }
        advance(p);
    }
}

void spl_ast_parse(spl_parser_t *parser, spl_ast_t *ast) {
    if (!ast || !ast->input.data || ast->node_buckets.size == 0)
        return;

    parser->ast = ast;
    parser->pos = 0;
    parser->failed = 0;
    parser->stop_agg = 0;

    spl_ast_node_ref_vec_t external_tags;
    vec_init(external_tags);
    spl_ast_node_ref_vec_t declarations;
    vec_init(declarations);

    while (!parser->failed) {
        const spl_tok_t *t = peek(parser);
        if (!t || t->type == TOK_EOF)
            break;

        if (t->type == TOK_AT || t->type == TOK_SHARP) {
            usize save_pos = parser->pos;
            const spl_tok_t *t2 = NULL;
            parser->pos++;
            t2 = peek(parser);
            parser->pos = save_pos;
            if (t2 && t2->type == TOK_NOT) {
                parse_tag_list(parser, &external_tags, 1, 1);
                continue;
            }
        }

        spl_ast_node_ref_t decl = parse_container_declaration(parser);
        if (decl) {
            vec_push(declarations, decl);
        } else if (!parser->failed) {
            const spl_tok_t *at = peek(parser);
            if (at && at->type != TOK_EOF) {
                skip_to_sync(parser);
            } else {
                break;
            }
        }
    }

    spl_ast_node_ref_t container_members = new_node(parser, SPL_AST_CONTAINER_MEMBERS, NULL);
    spl_ast_node_t *cm = node_at(ast, container_members);
    cm->container_members.external_tags = external_tags;
    cm->container_members.declarations = declarations;

    spl_ast_node_ref_t root = new_node(parser, SPL_AST_ROOT, NULL);
    node_at(ast, root)->root.members = container_members;

    ast->root = root;
}