stage1 修复错误 提供类型检查

stage0/spl_ir.h

@@ -13,7 +13,7 @@ typedef uintptr_t usize;
 typedef intptr_t isize;
 
 typedef enum {
-    SPL_VOID = 0,
+    SPL_VOID,
     SPL_I8,
     SPL_U8,
     SPL_I16,

stage0/spl_syscall.c

@@ -194,6 +194,14 @@ static spl_val_t vm_printf(int nargs, spl_val_t *args) {
             continue;
         }
         switch (fmt[i]) {
+        case '.': {
+            Assert(i + 2 < fmt_len && arg_idx + 1 <= nargs && fmt[i + 1] == '*' &&
+                   fmt[i + 2] == 's');
+            for (usize j = 0; j < args[arg_idx]; ++j) {
+                vec_push(buffer, ((const char *)args[arg_idx + 1])[j]);
+            }
+            i += 2;
+        } break;
         case 'd':
             snprintf(tmp_buf, sizeof(tmp_buf), "%zd", args[arg_idx]);
             for (usize j = 0; j < strlen(tmp_buf); ++j) {

stage1/spl_comp.c

@@ -16,6 +16,7 @@ void spl_comp_init(spl_comp_t *ctx) {
     map_init(ctx->const_values, MAP_HASH_STR, MAP_CMP_STR);
     spl_prog_init(&ctx->prog);
     ctx->error_msg[0] = '\0';
+    ctx->parse_context[0] = '\0';
     spl_emit_init(&ctx->emit, &ctx->prog);
     spl_type_ctx_init(&ctx->tctx);
     ctx->current_ret_type_idx = -1;
@@ -67,10 +68,38 @@ void spl_comp_reset(spl_comp_t *ctx) {
 }
 
 void spl_comp_error(spl_comp_t *ctx, const char *fmt, ...) {
+    if (ctx->has_error)
+        return;
+
+    char body[COMP_ERROR_MAX - 64];
     va_list args;
     va_start(args, fmt);
-    vsnprintf(ctx->error_msg, COMP_ERROR_MAX - 1, fmt, args);
+    vsnprintf(body, sizeof(body), fmt, args);
     va_end(args);
+
+    if (ctx->error_line > 0)
+        snprintf(ctx->error_msg, COMP_ERROR_MAX - 1, "line %zu:%zu: %s", ctx->error_line,
+                 ctx->error_col, body);
+    else
+        snprintf(ctx->error_msg, COMP_ERROR_MAX - 1, "%s", body);
+    ctx->has_error = 1;
+}
+
+void spl_comp_err_tok(spl_comp_t *ctx, spl_tok_t *tok, const char *fmt, ...) {
+    if (ctx->has_error)
+        return;
+
+    char body[COMP_ERROR_MAX - 64];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(body, sizeof(body), fmt, args);
+    va_end(args);
+
+    if (tok) {
+        snprintf(ctx->error_msg, COMP_ERROR_MAX - 1, "line %zu:%zu: %s", tok->line, tok->col, body);
+    } else {
+        snprintf(ctx->error_msg, COMP_ERROR_MAX - 1, "%s", body);
+    }
     ctx->has_error = 1;
 }
 

stage1/spl_comp.h

@@ -77,6 +77,8 @@ typedef struct spl_comp {
     /* Error state */
     char error_msg[COMP_ERROR_MAX];
     int has_error;
+    usize error_line;
+    usize error_col;
 
     /* Scopes */
     spl_scope_vec_t scopes;
@@ -91,6 +93,7 @@ typedef struct spl_comp {
     /* Current function context */
     int current_func_idx;
     int current_ret_type_idx;
+    char parse_context[COMP_ERROR_MAX]; /* current parsing context for error messages */
 
     /* Loop context for break/continue */
     int in_loop;
@@ -124,6 +127,7 @@ void spl_comp_reset(spl_comp_t *ctx);
 
 /* Error reporting */
 void spl_comp_error(spl_comp_t *ctx, const char *fmt, ...);
+void spl_comp_err_tok(spl_comp_t *ctx, spl_tok_t *tok, const char *fmt, ...);
 
 /* ============================================================
  * Parser functions (spl_parser.c)

stage1/spl_emit.c

@@ -185,6 +185,9 @@ void emit_patch_call_fixups(spl_emit_t *e, spl_prog_t *prog) {
         if (fe->func_idx >= 0 && fe->func_idx < (int)vec_size(prog->funcs)) {
             spl_val_t addr = vec_at(prog->funcs, fe->func_idx).address;
             vec_at(prog->insns, fe->insn_idx).imm = addr;
+        } else {
+            fprintf(stderr, "WARN: fixup func_idx=%d out of bounds [0,%zu), insn_idx=%zu\n",
+                    fe->func_idx, vec_size(prog->funcs), fe->insn_idx);
         }
     }
 }

stage1/spl_expr.c

@@ -93,7 +93,12 @@ static int spl_resolve_type_member(spl_comp_t *ctx, int type_idx, const char *fi
                 continue;
             if (strcmp(it->name, field) == 0) {
                 emit_push_i32(&ctx->emit, it->enum_field.value);
+                int data_type = it->enum_field.type_idx;
+                if (data_type >= 0) {
+                    *result = (spl_expr_result_t){data_type, 0};
+                } else {
                     *result = (spl_expr_result_t){type_idx, 0};
+                }
                 return 1;
             }
         }
@@ -278,14 +283,17 @@ static spl_expr_result_t parse_array_literal(spl_comp_t *ctx) {
 
     int len_val;
     if (!spl_parse_int_literal(ctx, &len_val)) {
-        spl_comp_error(ctx, "expected array length");
+        spl_comp_err_tok(ctx, peek(ctx), "expected array length");
         spl_expr_result_t r = {-1, 0};
         return r;
     }
     usize len = (usize)len_val;
 
     skip_nl(ctx);
-    expect(ctx, TOK_R_BRACKET);
+    if (!expect(ctx, TOK_R_BRACKET)) {
+        spl_expr_result_t r = {-1, 0};
+        return r;
+    }
     skip_nl(ctx);
 
     int elem_type_idx = spl_type_parse(&ctx->tctx, ctx);
@@ -295,7 +303,10 @@ static spl_expr_result_t parse_array_literal(spl_comp_t *ctx) {
     }
 
     skip_nl(ctx);
-    expect(ctx, TOK_L_BRACE);
+    if (!expect(ctx, TOK_L_BRACE)) {
+        spl_expr_result_t _r = {-1, 0};
+        return _r;
+    }
     skip_nl(ctx);
 
     for (usize i = 0; i < len; i++) {
@@ -311,7 +322,10 @@ static spl_expr_result_t parse_array_literal(spl_comp_t *ctx) {
         advance(ctx);
 
     skip_nl(ctx);
-    expect(ctx, TOK_R_BRACE);
+    if (!expect(ctx, TOK_R_BRACE)) {
+        spl_expr_result_t _r = {-1, 0};
+        return _r;
+    }
 
     int arr_type_idx = spl_type_array(&ctx->tctx, elem_type_idx, len);
     return (spl_expr_result_t){arr_type_idx, 0};
@@ -320,7 +334,8 @@ static spl_expr_result_t parse_array_literal(spl_comp_t *ctx) {
 static void parse_slice_inline(spl_comp_t *ctx) {
     advance(ctx);
     skip_nl(ctx);
-    while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+    skip_nl(ctx);
+    while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
         if (peek(ctx)->type == TOK_COMMA) {
             advance(ctx);
             skip_nl(ctx);
@@ -347,7 +362,8 @@ static void parse_slice_inline(spl_comp_t *ctx) {
         }
         skip_nl(ctx);
     }
-    expect(ctx, TOK_R_BRACE);
+    if (!expect(ctx, TOK_R_BRACE))
+        return;
     emit_drop(&ctx->emit);
 }
 
@@ -363,11 +379,13 @@ static void parse_one_field_init(spl_comp_t *ctx, spl_type_item_vec_t *items, in
         advance(ctx);
     skip_nl(ctx);
 
+    int found = 0;
     vec_for(*items, fi) {
         spl_type_item_t *it = &vec_at(*items, fi);
         if (it->item_kind != ITEM_FIELD)
             continue;
         if (strcmp(it->name, fname) == 0) {
+            found = 1;
             emit_laddr(&ctx->emit, base_offset);
             usize byte_off = extra_offset + it->aggregate_field.offset;
             emit_ptr_add(&ctx->emit, byte_off);
@@ -381,16 +399,17 @@ static void parse_one_field_init(spl_comp_t *ctx, spl_type_item_vec_t *items, in
                 skip_nl(ctx);
                 int len_val;
                 if (!spl_parse_int_literal(ctx, &len_val)) {
-                    spl_comp_error(ctx, "expected array length");
+                    spl_comp_err_tok(ctx, peek(ctx), "expected array length");
                     return;
                 }
                 usize arr_len = (usize)len_val;
                 skip_nl(ctx);
-                expect(ctx, TOK_R_BRACKET);
+                if (!expect(ctx, TOK_R_BRACKET))
+                    return;
                 skip_nl(ctx);
-                int elem_type_idx = spl_type_parse(&ctx->tctx, ctx);
+                int elem_type_idx = spl_type_elem_type(&ctx->tctx, ft_idx);
-                skip_nl(ctx);
+                if (!expect(ctx, TOK_L_BRACE))
-                expect(ctx, TOK_L_BRACE);
+                    return;
                 skip_nl(ctx);
                 usize stride = spl_type_elem_stride(&ctx->tctx, elem_type_idx);
                 spl_type_t st = spl_type_emit_type(&ctx->tctx, elem_type_idx);
@@ -417,7 +436,8 @@ static void parse_one_field_init(spl_comp_t *ctx, spl_type_item_vec_t *items, in
                 if (peek(ctx)->type == TOK_COMMA)
                     advance(ctx);
                 skip_nl(ctx);
-                expect(ctx, TOK_R_BRACE);
+                if (!expect(ctx, TOK_R_BRACE))
+                    return;
                 emit_drop(&ctx->emit);
             } else if (ft_idx >= 0 &&
                        (spl_type_kind(&ctx->tctx, ft_idx) == TYPE_STRUCT ||
@@ -444,6 +464,9 @@ static void parse_one_field_init(spl_comp_t *ctx, spl_type_item_vec_t *items, in
             break;
         }
     }
+    if (!found) {
+        spl_comp_err_tok(ctx, ftok, "unknown field '%s' in struct literal", fname);
+    }
 }
 
 spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
@@ -454,7 +477,7 @@ spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
     skip_nl(ctx);
 
     if (spl_type_kind(&ctx->tctx, type_idx) == TYPE_STRUCT) {
-        while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+        while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
             if (peek(ctx)->type == TOK_COMMA) {
                 advance(ctx);
                 skip_nl(ctx);
@@ -470,13 +493,7 @@ spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
             skip_nl(ctx);
         }
     } else if (spl_type_kind(&ctx->tctx, type_idx) == TYPE_SLICE) {
-        while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+        while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
-            if (peek(ctx)->type == TOK_COMMA) {
-                advance(ctx);
-                skip_nl(ctx);
-                continue;
-            }
-            if (peek(ctx)->type == TOK_DOT)
             advance(ctx);
             spl_tok_t *ftok = advance(ctx);
             char fname[256];
@@ -535,7 +552,8 @@ spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
                         peek(ctx)->type == TOK_L_BRACE) {
                         advance(ctx);
                         skip_nl(ctx);
-                        while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+                        while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE &&
+                               peek(ctx)->type != TOK_EOF) {
                             if (peek(ctx)->type == TOK_COMMA) {
                                 advance(ctx);
                                 skip_nl(ctx);
@@ -547,7 +565,10 @@ spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
                                                  base_offset, DATA_OFFSET);
                             skip_nl(ctx);
                         }
-                        expect(ctx, TOK_R_BRACE);
+                        if (!expect(ctx, TOK_R_BRACE)) {
+                            spl_expr_result_t _r = {-1, 0};
+                            return _r;
+                        }
                     } else if (dt_idx >= 0 &&
                                (spl_type_kind(&ctx->tctx, dt_idx) == TYPE_STRUCT ||
                                 spl_type_kind(&ctx->tctx, dt_idx) == TYPE_ENUM) &&
@@ -577,11 +598,14 @@ spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
             }
         }
         if (!found)
-            spl_comp_error(ctx, "unknown enum variant '%s'", vname);
+            spl_comp_err_tok(ctx, vtok, "unknown enum variant '%s'", vname);
     }
 
     skip_nl(ctx);
-    expect(ctx, TOK_R_BRACE);
+    if (!expect(ctx, TOK_R_BRACE)) {
+        spl_expr_result_t _r = {-1, 0};
+        return _r;
+    }
 
     if (sz <= sizeof(spl_val_t)) {
         emit_laddr(&ctx->emit, base_offset);
@@ -596,7 +620,7 @@ spl_expr_result_t spl_parse_struct_literal(spl_comp_t *ctx, int type_idx) {
 static int parse_call_args(spl_comp_t *ctx) {
     int nargs = 0;
     if (peek(ctx)->type != TOK_R_PAREN) {
-        for (;;) {
+        while (!ctx->has_error) {
             spl_parse_expr(ctx, PREC_MIN);
             nargs++;
             if (peek(ctx)->type == TOK_COMMA) {
@@ -609,24 +633,107 @@ static int parse_call_args(spl_comp_t *ctx) {
     return nargs;
 }
 
+static int types_equal(spl_type_ctx_t *tctx, int a, int b) {
+    if (a < 0 || b < 0)
+        return 0;
+    a = spl_type_resolve_underlying(tctx, a);
+    b = spl_type_resolve_underlying(tctx, b);
+    if (a == b)
+        return 1;
+
+    spl_type_kind_t ak = spl_type_kind(tctx, a);
+    spl_type_kind_t bk = spl_type_kind(tctx, b);
+    if (ak != bk)
+        return 0;
+
+    switch (ak) {
+    case TYPE_VOID:
+        return 1;
+    case TYPE_BASIC:
+        return spl_type_basic_type(tctx, a) == spl_type_basic_type(tctx, b);
+    case TYPE_PTR:
+        return types_equal(tctx, spl_type_elem_type(tctx, a), spl_type_elem_type(tctx, b));
+    case TYPE_ARRAY:
+        return spl_type_array_len(tctx, a) == spl_type_array_len(tctx, b) &&
+               types_equal(tctx, spl_type_elem_type(tctx, a), spl_type_elem_type(tctx, b));
+    case TYPE_SLICE:
+        return types_equal(tctx, spl_type_elem_type(tctx, a), spl_type_elem_type(tctx, b));
+    case TYPE_STRUCT:
+    case TYPE_UNION:
+    case TYPE_ENUM: {
+        const char *an = spl_type_name(tctx, a);
+        const char *bn = spl_type_name(tctx, b);
+        return an && bn && strcmp(an, bn) == 0;
+    }
+    default:
+        return 0;
+    }
+}
+
 static void spl_check_arg_type(spl_comp_t *ctx, const char *fname, int arg_type_idx,
                                int param_type_idx, int arg_idx) {
     if (arg_type_idx < 0 || param_type_idx < 0)
         return;
-    if (spl_type_kind(&ctx->tctx, param_type_idx) == TYPE_PTR &&
+
-        spl_type_elem_type(&ctx->tctx, param_type_idx) >= 0 &&
+    /* Level 1: structurally equal types */
-        spl_type_kind(&ctx->tctx, arg_type_idx) != TYPE_PTR &&
+    if (types_equal(&ctx->tctx, arg_type_idx, param_type_idx))
-        spl_type_name(&ctx->tctx, arg_type_idx) &&
+        return;
-        spl_type_name(&ctx->tctx, spl_type_elem_type(&ctx->tctx, param_type_idx)) &&
+
-        strcmp(spl_type_name(&ctx->tctx, arg_type_idx),
+    int arg_u = spl_type_resolve_underlying(&ctx->tctx, arg_type_idx);
-               spl_type_name(&ctx->tctx, spl_type_elem_type(&ctx->tctx, param_type_idx))) == 0) {
+    int param_u = spl_type_resolve_underlying(&ctx->tctx, param_type_idx);
+
+    /* Level 1b: void pointer (*_) accepts any pointer */
+    if (spl_type_kind(&ctx->tctx, param_u) == TYPE_PTR) {
+        int param_elem = spl_type_elem_type(&ctx->tctx, param_u);
+        int param_elem_u = spl_type_resolve_underlying(&ctx->tctx, param_elem);
+        if (param_elem_u >= 0 && spl_type_kind(&ctx->tctx, param_elem_u) == TYPE_BASIC &&
+            spl_type_basic_type(&ctx->tctx, param_elem_u) == SPL_VOID &&
+            spl_type_kind(&ctx->tctx, arg_u) == TYPE_PTR) {
+            return;
+        }
+    }
+
+    /* Level 2: pointer indirection mismatch with same inner type */
+    if (spl_type_kind(&ctx->tctx, param_u) == TYPE_PTR) {
+        int param_elem = spl_type_elem_type(&ctx->tctx, param_u);
+        if (param_elem < 0)
+            goto type_mismatch;
+
+        /* 2a: param = *T, arg = T  (missing '&') */
+        if (spl_type_kind(&ctx->tctx, arg_u) != TYPE_PTR) {
+            if (types_equal(&ctx->tctx, arg_type_idx, param_elem)) {
+                const char *is = spl_type_str(&ctx->tctx, param_elem);
                 fprintf(stderr,
                         "%s: warning: argument %d of '%s' expects '%s*', "
                         "got '%s' (missing '&'?)\n",
-                ctx->fname, arg_idx + 1, fname,
+                        ctx->fname, arg_idx + 1, fname, is, is);
-                spl_type_name(&ctx->tctx, spl_type_elem_type(&ctx->tctx, param_type_idx)),
+                return;
-                spl_type_name(&ctx->tctx, arg_type_idx));
             }
+        }
+
+        /* 2b: param = *T, arg = **T  (extra '&') */
+        if (spl_type_kind(&ctx->tctx, arg_u) == TYPE_PTR) {
+            int arg_elem = spl_type_elem_type(&ctx->tctx, arg_u);
+            int arg_elem_u = spl_type_resolve_underlying(&ctx->tctx, arg_elem);
+            if (spl_type_kind(&ctx->tctx, arg_elem_u) == TYPE_PTR) {
+                if (types_equal(&ctx->tctx, spl_type_elem_type(&ctx->tctx, arg_elem), param_elem)) {
+                    const char *is = spl_type_str(&ctx->tctx, param_elem);
+                    fprintf(stderr,
+                            "%s: warning: argument %d of '%s' expects '%s*', "
+                            "got '%s**' (extra '&'?)\n",
+                            ctx->fname, arg_idx + 1, fname, is, is);
+                    return;
+                }
+            }
+        }
+    }
+
+    /* Level 3: general type mismatch → error */
+type_mismatch:;
+    const char *as = spl_type_str(&ctx->tctx, arg_type_idx);
+    const char *ps = spl_type_str(&ctx->tctx, param_type_idx);
+    spl_comp_err_tok(ctx, peek(ctx), "argument %d of '%s' type mismatch: expected '%s', got '%s'",
+                     arg_idx + 1, fname, ps, as);
 }
 
 static int parse_call_args_checked(spl_comp_t *ctx, const char *fname, int *param_type_indices,
@@ -634,11 +741,20 @@ static int parse_call_args_checked(spl_comp_t *ctx, const char *fname, int *para
     int nargs = 0;
     int nlogical = 0;
     if (peek(ctx)->type != TOK_R_PAREN) {
-        for (;;) {
+        while (!ctx->has_error) {
             spl_expr_result_t arg = spl_parse_expr(ctx, PREC_MIN);
-            if (param_type_indices && nlogical < nparams && param_type_indices[nlogical] >= 0)
+            if (param_type_indices && nlogical < nparams && param_type_indices[nlogical] >= 0) {
+                int param_u = spl_type_resolve_underlying(&ctx->tctx, param_type_indices[nlogical]);
+                int arg_u = spl_type_resolve_underlying(&ctx->tctx, arg.type_idx);
+                if (arg.type_idx >= 0 && spl_type_kind(&ctx->tctx, param_u) == TYPE_BASIC &&
+                    spl_type_is_integer(spl_type_basic_type(&ctx->tctx, param_u)) &&
+                    spl_type_kind(&ctx->tctx, arg_u) == TYPE_BASIC &&
+                    spl_type_is_integer(spl_type_basic_type(&ctx->tctx, arg_u))) {
+                    arg.type_idx = param_type_indices[nlogical];
+                }
                 spl_check_arg_type(ctx, fname, arg.type_idx, param_type_indices[nlogical],
                                    nlogical);
+            }
 
             int arg_slots = 1;
             if (param_type_indices && nlogical < nparams && param_type_indices[nlogical] >= 0 &&
@@ -678,7 +794,17 @@ static spl_expr_result_t parse_ident(spl_comp_t *ctx) {
     if (peek(ctx)->type == TOK_L_PAREN) {
         int fi = spl_lookup_func(ctx, name);
         if (fi < 0) {
-            spl_comp_error(ctx, "unknown function '%s'", name);
+            /* Not a known function — check if it's a function pointer variable */
+            spl_var_info_t *v = spl_lookup_var(ctx, name);
+            if (v && v->type_idx >= 0 && spl_type_kind(&ctx->tctx, v->type_idx) == TYPE_FN) {
+                /* Load function pointer value, let postfix handle the call */
+                int vt_idx = v->type_idx;
+                emit_laddr(&ctx->emit, v->offset);
+                emit_load_ptr(&ctx->emit);
+                spl_expr_result_t r = {vt_idx, 0};
+                return r;
+            }
+            spl_comp_err_tok(ctx, t, "unknown function '%s'", name);
             spl_expr_result_t r = {-1, 0};
             return r;
         }
@@ -686,12 +812,28 @@ static spl_expr_result_t parse_ident(spl_comp_t *ctx) {
         advance(ctx);
 
         int nargs = parse_call_args_checked(ctx, f->name, f->param_type_indices, f->nparams);
-        expect(ctx, TOK_R_PAREN);
+        if (!ctx->has_error && nargs < f->nparams) {
+            spl_comp_err_tok(ctx, peek(ctx), "too few arguments to '%s': expected %d, got %d",
+                             f->name, f->nparams, nargs);
+        }
+        if (!ctx->has_error) {
+            if (!expect(ctx, TOK_R_PAREN)) {
+                spl_expr_result_t _r = {-1, 0};
+                return _r;
+            }
+        } else {
+            spl_expr_result_t _r = {-1, 0};
+            return _r;
+        }
 
         if (f->is_extern) {
             int nidx = spl_ensure_native(ctx, f->name);
             emit_push_i32(&ctx->emit, nidx);
             emit_ncall(&ctx->emit, nargs);
+            if (spl_type_kind(&ctx->tctx, f->ret_type_idx) == TYPE_BASIC &&
+                spl_type_basic_type(&ctx->tctx, f->ret_type_idx) == SPL_VOID) {
+                emit_drop(&ctx->emit);
+            }
         } else {
             emit_call_with_fixup(&ctx->emit, nargs, f->func_idx);
         }
@@ -722,10 +864,30 @@ static spl_expr_result_t parse_ident(spl_comp_t *ctx) {
         emit_laddr(&ctx->emit, v->offset);
 
         spl_expr_result_t r;
+        spl_tok_type_t next_type = peek(ctx)->type;
+        if (next_type == TOK_DOT) {
+            r = (spl_expr_result_t){vt_idx, 1};
+        } else {
             emit_load_or_addr_type(ctx, &r, vt_idx);
+        }
         return r;
     }
 
+    /* Function reference (not a call): get function address */
+    {
+        int fi = spl_lookup_func(ctx, name);
+        if (fi >= 0) {
+            spl_func_info_t *f = &vec_at(ctx->funcs, fi);
+            if (!f->is_extern) {
+                emit_push_u64(&ctx->emit, f->func_idx);
+                int fn_ptr_type =
+                    spl_type_fn(&ctx->tctx, spl_type_basic(&ctx->tctx, SPL_USIZE), f->ret_type_idx);
+                spl_expr_result_t r = {fn_ptr_type, 1};
+                return r;
+            }
+        }
+    }
+
     int ttype_idx = spl_type_resolve(&ctx->tctx, name);
     if (ttype_idx >= 0) {
         if (peek(ctx)->type == TOK_L_BRACE &&
@@ -737,7 +899,7 @@ static spl_expr_result_t parse_ident(spl_comp_t *ctx) {
         return r;
     }
 
-    spl_comp_error(ctx, "undefined variable '%s'", name);
+    spl_comp_err_tok(ctx, t, "undefined variable '%s'", name);
     spl_expr_result_t r = {-1, 0};
     return r;
 }
@@ -745,7 +907,10 @@ static spl_expr_result_t parse_ident(spl_comp_t *ctx) {
 static spl_expr_result_t parse_group(spl_comp_t *ctx) {
     advance(ctx);
     spl_expr_result_t r = spl_parse_expr(ctx, PREC_MIN);
-    expect(ctx, TOK_R_PAREN);
+    if (!ctx->has_error) {
+        if (!expect(ctx, TOK_R_PAREN))
+            return r;
+    }
     return r;
 }
 
@@ -781,8 +946,13 @@ static spl_expr_result_t parse_prefix_op(spl_comp_t *ctx) {
         emit_binop(&ctx->emit, SPL_NOT, spl_type_emit_type(&ctx->tctx, right.type_idx));
         break;
     case TOK_AND:
+        if (right.type_idx >= 0 && spl_type_kind(&ctx->tctx, right.type_idx) == TYPE_FN) {
+            return right;
+        }
         if (!right.is_lvalue) {
-            spl_comp_error(ctx, "cannot take address of rvalue");
+            spl_comp_err_tok(ctx, peek(ctx), "cannot take address of rvalue");
+            spl_expr_result_t _r = {-1, 0};
+            return _r;
         }
         right.type_idx = spl_type_ptr(&ctx->tctx, right.type_idx);
         break;
@@ -852,7 +1022,7 @@ static spl_expr_result_t parse_primary_expr(spl_comp_t *ctx) {
         skip_nl(ctx);
         tok = peek(ctx);
         if (!tok || tok->type != TOK_IDENT) {
-            spl_comp_error(ctx, "expected builtin name after '@'");
+            spl_comp_err_tok(ctx, tok, "expected builtin name after '@'");
             spl_expr_result_t r = {-1, 0};
             return r;
         }
@@ -864,7 +1034,15 @@ static spl_expr_result_t parse_primary_expr(spl_comp_t *ctx) {
             if (peek(ctx)->type == TOK_L_PAREN) {
                 advance(ctx);
                 int nargs = parse_call_args(ctx);
-                expect(ctx, TOK_R_PAREN);
+                if (!ctx->has_error) {
+                    if (!expect(ctx, TOK_R_PAREN)) {
+                        spl_expr_result_t _r = {-1, 0};
+                        return _r;
+                    }
+                } else {
+                    spl_expr_result_t _r = {-1, 0};
+                    return _r;
+                }
                 for (int i = 0; i < nargs; i++) {
                     emit_dbg_usize(&ctx->emit);
                     emit_drop(&ctx->emit);
@@ -876,11 +1054,22 @@ static spl_expr_result_t parse_primary_expr(spl_comp_t *ctx) {
             }
             return (spl_expr_result_t){spl_type_basic(&ctx->tctx, SPL_VOID), 0};
         } else if (strcmp(bname, "sizeof") == 0) {
-            expect(ctx, TOK_L_PAREN);
+            if (!expect(ctx, TOK_L_PAREN)) {
+                spl_expr_result_t _r = {-1, 0};
+                return _r;
+            }
             int ti = spl_type_parse(&ctx->tctx, ctx);
-            expect(ctx, TOK_R_PAREN);
+            if (!ctx->has_error) {
+                if (!expect(ctx, TOK_R_PAREN)) {
+                    spl_expr_result_t _r = {-1, 0};
+                    return _r;
+                }
+            } else {
+                spl_expr_result_t _r = {-1, 0};
+                return _r;
+            }
             if (ti < 0) {
-                spl_comp_error(ctx, "@sizeof: invalid type");
+                spl_comp_err_tok(ctx, peek(ctx), "@sizeof: invalid type");
                 spl_expr_result_t r = {-1, 0};
                 return r;
             }
@@ -888,13 +1077,13 @@ static spl_expr_result_t parse_primary_expr(spl_comp_t *ctx) {
             emit_push_usize(&ctx->emit, sz);
             return (spl_expr_result_t){spl_type_basic(&ctx->tctx, SPL_USIZE), 0};
         } else {
-            spl_comp_error(ctx, "unknown builtin '@%s'", bname);
+            spl_comp_err_tok(ctx, peek(ctx), "unknown builtin '@%s'", bname);
             spl_expr_result_t r = {-1, 0};
             return r;
         }
     }
     default:
-        if (peek(ctx)->type >= KW_AS && peek(ctx)->type <= KW_ANY) {
+        if (peek(ctx)->type > KW_AS && peek(ctx)->type <= KW_ANY) {
             return parse_ident(ctx);
         }
         spl_expr_result_t r = {-1, 0};
@@ -907,6 +1096,8 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
         return left;
 
     for (;;) {
+        if (ctx->has_error)
+            break;
         skip_nl(ctx);
         spl_tok_type_t opt = peek(ctx)->type;
 
@@ -961,20 +1152,43 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
 
                         if (is_instance) {
                             if (!left.is_lvalue && !is_ptr_self) {
-                                spl_comp_error(ctx, "cannot call instance method '%s' on type",
+                                spl_comp_err_tok(ctx, field,
-                                               fname);
+                                                 "cannot call instance method '%s' on type", fname);
+                                return left;
                             }
                             emit_drop(&ctx->emit);
                             nargs = 0;
                         }
 
                         {
-                            int *cp = func->param_type_indices;
+                            int full_np = func->nparams;
-                            int cn = func->nparams;
+                            nargs += parse_call_args_checked(ctx, func->name,
-                            nargs += parse_call_args_checked(ctx, func->name, cp, cn);
+                                                             func->param_type_indices, full_np);
+                            if (is_instance && !ctx->has_error) {
+                                int ok =
+                                    (nargs >= full_np) || (nargs == full_np - 1 && full_np == 1);
+                                if (!ok) {
+                                    spl_comp_err_tok(
+                                        ctx, peek(ctx),
+                                        "too few arguments to '%s': expected %d, got %d",
+                                        func->name, full_np, nargs);
+                                }
+                            }
+                        }
+                        if (!ctx->has_error) {
+                            if (!expect(ctx, TOK_R_PAREN)) {
+                                spl_expr_result_t _r = left;
+                                return _r;
+                            }
+                        } else {
+                            spl_expr_result_t _r = left;
+                            return _r;
                         }
-                        expect(ctx, TOK_R_PAREN);
 
+                        if (func->func_idx < 0) {
+                            fprintf(stderr, "WARN: method call '%s.' with invalid func_idx=%d\n",
+                                    func->name, func->func_idx);
+                        }
                         emit_call_with_fixup(&ctx->emit, nargs, func->func_idx);
 
                         left = (spl_expr_result_t){func->ret_type_idx, 0};
@@ -992,10 +1206,53 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                 }
                 if (found_method)
                     continue;
+
+                /* Indirect call through function pointer: fn_ptr(args) */
+                if (left.type_idx >= 0 && peek(ctx)->type == TOK_L_PAREN &&
+                    spl_type_kind(&ctx->tctx, left.type_idx) == TYPE_FN) {
+                    advance(ctx); /* ( */
+
+                    int nargs = parse_call_args(ctx);
+                    if (!ctx->has_error) {
+                        if (!expect(ctx, TOK_R_PAREN)) {
+                            spl_expr_result_t _r = left;
+                            return _r;
+                        }
+                    } else {
+                        spl_expr_result_t _r = left;
+                        return _r;
+                    }
+
+                    /* If left is lvalue, load the function address value first */
+                    if (left.is_lvalue) {
+                        emit_load_ptr(&ctx->emit);
+                    }
+
+                    /* Stack currently: [args..., func_addr].
+                     * CALLI expects: POP addr, POP nargs, call(addr, nargs).
+                     * After all args are on stack: push nargs, push func_addr.
+                     * But func_addr is already below args? No — we need:
+                     * Stack: [..., func_addr, arg0, ..., argN-1]
+                     * CALLI: POP addr, POP nargs, call(addr, nargs)
+                     * Actually CALLI pops: TOS=addr, TOS-1=nargs.
+                     * So we need: [args..., nargs, addr]
+                     * But currently: [args..., addr] (addr is on TOS, loaded above)
+                     * Push nargs ABOVE addr, then CALLI pops addr, then nargs:
+                     * Stack: [args..., nargs, addr]
+                     * TOS=addr → POP returns addr, then POP returns nargs. ✓ */
+
+                    emit_push_u64(&ctx->emit, nargs);
+                    emit_raw(&ctx->emit, SPL_CALLI, SPL_VOID, 0);
+
+                    /* For now, result type is void — we don't know the return type from fn ptr */
+                    left = (spl_expr_result_t){spl_type_basic(&ctx->tctx, SPL_VOID), 0};
+                    continue;
+                }
             }
 
             if (left.type_idx >= 0 && spl_type_kind(&ctx->tctx, left.type_idx) == TYPE_STRUCT) {
                 spl_type_item_vec_t *f_items = spl_type_items(&ctx->tctx, left.type_idx);
+                int found = 0;
                 vec_for(*f_items, fi) {
                     spl_type_item_t *fit = &vec_at(*f_items, fi);
                     if (fit->item_kind != ITEM_FIELD)
@@ -1003,9 +1260,11 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                     if (strcmp(fit->name, fname) == 0) {
                         emit_ptr_add(&ctx->emit, fit->aggregate_field.offset);
                         emit_load_or_addr_type(ctx, &left, fit->aggregate_field.type_idx);
+                        found = 1;
                         break;
                     }
                 }
+                if (found)
                     continue;
             }
 
@@ -1016,6 +1275,7 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                         emit_load_ptr(&ctx->emit);
                     }
                     spl_type_item_vec_t *st_items = spl_type_items(&ctx->tctx, elem_idx);
+                    int found = 0;
                     vec_for(*st_items, si) {
                         spl_type_item_t *sit = &vec_at(*st_items, si);
                         if (sit->item_kind != ITEM_FIELD)
@@ -1023,9 +1283,11 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                         if (strcmp(sit->name, fname) == 0) {
                             emit_ptr_add(&ctx->emit, sit->aggregate_field.offset);
                             emit_load_or_addr_type(ctx, &left, sit->aggregate_field.type_idx);
+                            found = 1;
                             break;
                         }
                     }
+                    if (found)
                         continue;
                 }
             }
@@ -1072,7 +1334,7 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                 continue;
             }
 
-            spl_comp_error(ctx, "unknown field '%s'", fname);
+            spl_comp_err_tok(ctx, field, "unknown field '%s'", fname);
             continue;
         }
 
@@ -1099,7 +1361,8 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                     ctx->addr_of_mode = saved_aom;
                 }
                 (void)end_expr;
-                expect(ctx, TOK_R_BRACKET);
+                if (!expect(ctx, TOK_R_BRACKET))
+                    return left;
 
                 if (!has_explicit_end) {
                     if (left.type_idx >= 0 &&
@@ -1148,7 +1411,8 @@ static spl_expr_result_t parse_postfix_expr(spl_comp_t *ctx, spl_expr_result_t l
                 continue;
             }
 
-            expect(ctx, TOK_R_BRACKET);
+            if (!expect(ctx, TOK_R_BRACKET))
+                break;
 
             if (left.type_idx >= 0 && (spl_type_kind(&ctx->tctx, left.type_idx) == TYPE_ARRAY ||
                                        spl_type_kind(&ctx->tctx, left.type_idx) == TYPE_PTR ||
@@ -1217,8 +1481,7 @@ spl_expr_result_t spl_parse_expr(spl_comp_t *ctx, int min_prec) {
     spl_expr_result_t left = parse_primary_expr(ctx);
     if (left.type_idx < 0)
         return left;
-
+    while (!ctx->has_error) {
-    while (1) {
         left = parse_postfix_expr(ctx, left);
 
         skip_nl(ctx);
@@ -1291,7 +1554,7 @@ static spl_expr_result_t parse_infix(spl_comp_t *ctx, spl_expr_result_t left, sp
     spl_parse_expr(ctx, next_prec);
     if ((op == TOK_EQ || op == TOK_NEQ) && left.type_idx >= 0 &&
         !spl_type_is_scalar(&ctx->tctx, left.type_idx)) {
-        spl_comp_error(ctx, "type '%s' does not support comparison",
+        spl_comp_err_tok(ctx, peek(ctx), "type '%s' does not support comparison",
                          spl_type_str(&ctx->tctx, left.type_idx));
     }
     spl_type_t bt = spl_type_emit_type(&ctx->tctx, left.type_idx);
@@ -1307,29 +1570,27 @@ static spl_expr_result_t parse_infix(spl_comp_t *ctx, spl_expr_result_t left, sp
 
 int spl_emit_match_enum_cmp(spl_comp_t *ctx, int enum_type_idx, int val_offset, int by_value) {
     char vname[256];
+    spl_tok_t *vtok = NULL;
 
     if (peek(ctx)->type == TOK_DOT) {
         advance(ctx);
+        vtok = advance(ctx);
+        spl_tok_copy_name(vtok, vname, sizeof(vname));
     } else {
-        spl_tok_t *tok = advance(ctx);
+        vtok = advance(ctx);
-        spl_tok_copy_name(tok, vname, sizeof(vname));
+        spl_tok_copy_name(vtok, vname, sizeof(vname));
 
         while (peek(ctx)->type == TOK_DOT) {
             int qt_idx = spl_type_resolve(&ctx->tctx, vname);
             (void)qt_idx;
             advance(ctx);
-            tok = advance(ctx);
+            vtok = advance(ctx);
-            spl_tok_copy_name(tok, vname, sizeof(vname));
+            spl_tok_copy_name(vtok, vname, sizeof(vname));
         }
 
         goto lookup;
     }
 
-    {
-        spl_tok_t *vtok = advance(ctx);
-        spl_tok_copy_name(vtok, vname, sizeof(vname));
-    }
-
 lookup: {
     spl_type_item_vec_t *e_items = spl_type_items(&ctx->tctx, enum_type_idx);
     vec_for(*e_items, vi) {
@@ -1351,7 +1612,7 @@ lookup: {
         }
     }
 }
-    spl_comp_error(ctx, "unknown variant '%s' in match", vname);
+    spl_comp_err_tok(ctx, vtok, "unknown variant '%s' in match", vname);
     return -1;
 }
 

stage1/spl_lex_util.c

@@ -14,12 +14,30 @@ spl_tok_t *advance(spl_comp_t *ctx) {
 }
 
 int expect(spl_comp_t *ctx, spl_tok_type_t type) {
-    if (peek(ctx)->type == type) {
+    spl_tok_t *tok = peek(ctx);
+    if (tok->type == type) {
         advance(ctx);
         return 1;
     }
-    spl_comp_error(ctx, "expected '%s', got '%s'", spl_tok_type_name(type),
+
-                   spl_tok_type_name(peek(ctx)->type));
+    /* Extract token text for display (up to 40 chars) */
+    char val_buf[64];
+    usize display_len = tok->len < 40 ? tok->len : 40;
+    memcpy(val_buf, tok->lexeme, display_len);
+    val_buf[display_len] = '\0';
+    /* Replace newlines with \n for display */
+    for (usize i = 0; i < display_len; i++) {
+        if (val_buf[i] == '\n')
+            val_buf[i] = ' ';
+    }
+
+    if (ctx->parse_context[0]) {
+        spl_comp_err_tok(ctx, tok, "%s: expected %s, got %s '%s'", ctx->parse_context,
+                         spl_tok_type_name(type), spl_tok_type_name(tok->type), val_buf);
+    } else {
+        spl_comp_err_tok(ctx, tok, "expected %s, got %s '%s'", spl_tok_type_name(type),
+                         spl_tok_type_name(tok->type), val_buf);
+    }
     return 0;
 }
 

stage1/spl_parser.c

@@ -14,7 +14,21 @@ static int parse_params_decl(spl_comp_t *ctx, char pnames[][256], int ptypes[])
     int nparams = 0;
     skip_nl(ctx);
     if (peek(ctx)->type != TOK_R_PAREN) {
+        {
+            usize saved = ctx->tok_idx;
+            spl_tok_t *ptok = advance(ctx);
+            skip_nl(ctx);
+            if (ptok->type == KW_VOID && peek(ctx)->type == TOK_R_PAREN) {
+                expect(ctx, TOK_R_PAREN);
+                return 0;
+            }
+            ctx->tok_idx = saved;
+        }
         while (1) {
+            if (peek(ctx)->type == TOK_ELLIPSIS) {
+                advance(ctx);
+                break;
+            }
             spl_tok_t *pname = advance(ctx);
             spl_tok_copy_name(pname, pnames[nparams], 256);
             skip_nl(ctx);
@@ -32,10 +46,6 @@ static int parse_params_decl(spl_comp_t *ctx, char pnames[][256], int ptypes[])
                 skip_nl(ctx);
                 continue;
             }
-            if (peek(ctx)->type == TOK_ELLIPSIS) {
-                advance(ctx);
-                skip_nl(ctx);
-            }
             break;
         }
     }
@@ -45,6 +55,7 @@ static int parse_params_decl(spl_comp_t *ctx, char pnames[][256], int ptypes[])
 
 static int parse_fn_body(spl_comp_t *ctx, const char *fn_name, int ret_type_idx, int nparams,
                          char pnames[][256], int ptypes[], int is_pub) {
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "function '%s'", fn_name);
     int fi = spl_declare_func(ctx, fn_name, ret_type_idx, nparams, 0, is_pub);
 
     {
@@ -75,11 +86,35 @@ static int parse_fn_body(spl_comp_t *ctx, const char *fn_name, int ret_type_idx,
         spl_val_t alloc_addr = vec_size(ctx->prog.insns);
         emit_alloc(&ctx->emit, 0);
 
-        while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+        while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
             spl_parse_stmt(ctx);
             skip_nl(ctx);
         }
 
+        /* Error recovery: skip to matching } if has_error caused early exit */
+        if (ctx->has_error) {
+            int depth = 1;
+            while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+                spl_tok_type_t tt = peek(ctx)->type;
+                if (tt == TOK_L_BRACE)
+                    depth++;
+                else if (tt == TOK_R_BRACE) {
+                    depth--;
+                    if (depth == 0)
+                        break;
+                } else if (tt == TOK_EOF)
+                    break;
+                advance(ctx);
+            }
+            if (peek(ctx)->type == TOK_R_BRACE)
+                advance(ctx);
+            else
+                return 0;
+        } else {
+            if (!expect(ctx, TOK_R_BRACE))
+                return 0;
+        }
+
         int total_phys_slots = 0;
         for (int i = 0; i < nparams; i++) {
             usize psz = spl_type_size(&ctx->tctx, ptypes[i]);
@@ -90,9 +125,14 @@ static int parse_fn_body(spl_comp_t *ctx, const char *fn_name, int ret_type_idx,
             if ((usize)ctx->emit.frame.peak_bytes < min_bytes)
                 ctx->emit.frame.peak_bytes = (int)min_bytes;
         }
-        emit_patch(&ctx->emit, alloc_addr,
+        int alloc_slots = ctx->emit.frame.peak_bytes / (int)sizeof(spl_val_t) - total_phys_slots;
-                   ctx->emit.frame.peak_bytes / (int)sizeof(spl_val_t) - total_phys_slots);
+        if (alloc_slots < 0 || alloc_slots > 65536) {
-        expect(ctx, TOK_R_BRACE);
+            fprintf(
+                stderr,
+                "WARN: parse_fn_body: suspicious alloc_slots=%d (peak_bytes=%d, phys_slots=%d)\n",
+                alloc_slots, ctx->emit.frame.peak_bytes, total_phys_slots);
+        }
+        emit_patch(&ctx->emit, alloc_addr, alloc_slots);
     }
 
     spl_emit_defer_epilogue(ctx, ctx->scope_depth);
@@ -116,7 +156,8 @@ static void parse_fn_decl(spl_comp_t *ctx, int is_extern, int is_pub) {
     char fn_name[256];
     spl_tok_copy_name(fname_tok, fn_name, sizeof(fn_name));
     skip_nl(ctx);
-    expect(ctx, TOK_L_PAREN);
+    if (!expect(ctx, TOK_L_PAREN))
+        return;
 
     char pnames[MAX_PARAMS][256];
     int ptypes[MAX_PARAMS];
@@ -170,7 +211,8 @@ static void parse_method_decl(spl_comp_t *ctx, int container_type_idx) {
     snprintf(qualified, sizeof(qualified), "%s.%s", cname ? cname : "anon", mname);
 
     skip_nl(ctx);
-    expect(ctx, TOK_L_PAREN);
+    if (!expect(ctx, TOK_L_PAREN))
+        return;
 
     char pnames[MAX_PARAMS][256];
     int ptypes[MAX_PARAMS];
@@ -194,42 +236,6 @@ static void parse_method_decl(spl_comp_t *ctx, int container_type_idx) {
  * Parse type container body (shared for struct, union, enum)
  * ============================================================ */
 
-static void skip_type_decl(spl_comp_t *ctx) {
-    advance(ctx); /* type */
-    advance(ctx); /* name */
-    skip_nl(ctx);
-    expect(ctx, TOK_ASSIGN);
-    skip_nl(ctx);
-
-    spl_tok_type_t tt = peek(ctx)->type;
-    if (tt == KW_STRUCT || tt == KW_UNION || tt == KW_ENUM) {
-        advance(ctx);
-        skip_nl(ctx);
-    }
-
-    if (peek(ctx)->type == TOK_L_BRACE) {
-        int bd = 1;
-        advance(ctx);
-        while (bd > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
-            spl_tok_type_t tt = peek(ctx)->type;
-            if (tt == TOK_L_BRACE)
-                bd++;
-            else if (tt == TOK_R_BRACE)
-                bd--;
-            else if (tt == TOK_EOF)
-                break;
-            advance(ctx);
-        }
-    } else {
-        while (peek(ctx)->type != TOK_SEMICOLON && peek(ctx)->type != TOK_EOF)
-            advance(ctx);
-    }
-
-    skip_nl(ctx);
-    if (peek(ctx)->type == TOK_SEMICOLON)
-        advance(ctx);
-}
-
 static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum) {
     if (peek(ctx)->type != TOK_L_BRACE)
         return;
@@ -242,7 +248,7 @@ static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum
     {
         usize saved = ctx->tok_idx;
         int depth = 1;
-        while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+        while (!ctx->has_error && depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
             spl_tok_type_t tt = peek(ctx)->type;
             if (tt == TOK_L_BRACE) {
                 depth++;
@@ -269,7 +275,7 @@ static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum
         if (cname) {
             usize saved = ctx->tok_idx;
             int depth = 1;
-            while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+            while (!ctx->has_error && depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
                 spl_tok_type_t tt = peek(ctx)->type;
                 if (tt == TOK_L_BRACE) {
                     depth++;
@@ -325,7 +331,7 @@ static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum
     /* === Pass 2: Parse fields/variants and methods === */
     {
         int depth = 1;
-        while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+        while (!ctx->has_error && depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
             skip_nl(ctx);
             spl_tok_type_t tt = peek(ctx)->type;
             if (tt == TOK_L_BRACE) {
@@ -339,7 +345,7 @@ static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum
                 }
                 advance(ctx);
             } else if (tt == KW_TYPE && depth == 1) {
-                skip_type_decl(ctx);
+                parse_type_decl(ctx);
             } else if (tt == KW_VAR && depth == 1 && !is_enum) {
                 advance(ctx); /* var */
                 skip_nl(ctx);
@@ -352,7 +358,7 @@ static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum
                     char fname[256];
                     spl_tok_copy_name(ftok, fname, sizeof(fname));
                     if (ftype >= 0)
-                        spl_type_add_field(&ctx->tctx, container_type_idx, fname, ftype);
+                        spl_type_add_var(&ctx->tctx, container_type_idx, fname, ftype);
                 }
                 skip_nl(ctx);
                 if (peek(ctx)->type == TOK_SEMICOLON || peek(ctx)->type == TOK_COMMA)
@@ -402,7 +408,6 @@ static void parse_type_body(spl_comp_t *ctx, int container_type_idx, int is_enum
     }
 
     ctx->tctx.current_type_idx = saved_current;
-    spl_type_compute_layout(&ctx->tctx, container_type_idx);
 }
 
 /* ============================================================
@@ -414,31 +419,48 @@ void parse_type_decl(spl_comp_t *ctx) {
     spl_tok_t *name_tok = advance(ctx);
     char tname[256];
     spl_tok_copy_name(name_tok, tname, sizeof(tname));
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "type '%s'", tname);
 
     skip_nl(ctx);
-    expect(ctx, TOK_ASSIGN);
+    if (!expect(ctx, TOK_ASSIGN))
+        return;
     skip_nl(ctx);
 
     int parent_type_idx = ctx->tctx.current_type_idx;
 
+    /* Check if already pre-registered in Pass 0 */
+    int existing = spl_type_resolve(&ctx->tctx, tname);
+
     if (peek(ctx)->type == KW_STRUCT) {
         advance(ctx);
-        int ti = spl_type_struct(&ctx->tctx, tname);
+        int ti;
-        if (parent_type_idx >= 0)
+        if (existing >= 0)
+            ti = existing;
+        else
+            ti = spl_type_struct(&ctx->tctx, tname);
+        if (parent_type_idx >= 0 && existing < 0)
             spl_type_add_nested(&ctx->tctx, parent_type_idx, tname, ti);
         skip_nl(ctx);
         parse_type_body(ctx, ti, 0);
     } else if (peek(ctx)->type == KW_UNION) {
         advance(ctx);
-        int ti = spl_type_union(&ctx->tctx, tname);
+        int ti;
-        if (parent_type_idx >= 0)
+        if (existing >= 0)
+            ti = existing;
+        else
+            ti = spl_type_union(&ctx->tctx, tname);
+        if (parent_type_idx >= 0 && existing < 0)
             spl_type_add_nested(&ctx->tctx, parent_type_idx, tname, ti);
         skip_nl(ctx);
         parse_type_body(ctx, ti, 1);
     } else if (peek(ctx)->type == KW_ENUM) {
         advance(ctx);
-        int ti = spl_type_enum(&ctx->tctx, tname);
+        int ti;
-        if (parent_type_idx >= 0)
+        if (existing >= 0)
+            ti = existing;
+        else
+            ti = spl_type_enum(&ctx->tctx, tname);
+        if (parent_type_idx >= 0 && existing < 0)
             spl_type_add_nested(&ctx->tctx, parent_type_idx, tname, ti);
         skip_nl(ctx);
         parse_type_body(ctx, ti, 1);
@@ -455,12 +477,213 @@ void parse_type_decl(spl_comp_t *ctx) {
         advance(ctx);
 }
 
+/* ============================================================
+ * Pre-registration pass: register all names before filling bodies
+ * ============================================================ */
+
+/* Skip a { ... } function body */
+static void skip_fn_body(spl_comp_t *ctx) {
+    int depth = 1;
+    while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+        spl_tok_type_t tt = peek(ctx)->type;
+        if (tt == TOK_L_BRACE)
+            depth++;
+        else if (tt == TOK_R_BRACE) {
+            depth--;
+            if (depth == 0)
+                break;
+        } else if (tt == TOK_EOF)
+            break;
+        advance(ctx);
+    }
+    if (peek(ctx)->type == TOK_R_BRACE)
+        advance(ctx);
+}
+
+/* Pre-register a type name (and nested type names), skip the body */
+static void pre_register_type_decl(spl_comp_t *ctx) {
+    advance(ctx); /* type */
+    spl_tok_t *name_tok = advance(ctx);
+    char tname[256];
+    spl_tok_copy_name(name_tok, tname, sizeof(tname));
+    skip_nl(ctx);
+    if (!expect(ctx, TOK_ASSIGN))
+        return;
+    skip_nl(ctx);
+
+    int parent_type_idx = ctx->tctx.current_type_idx;
+
+    int ti = -1;
+    if (peek(ctx)->type == KW_STRUCT) {
+        advance(ctx);
+        ti = spl_type_struct(&ctx->tctx, tname);
+    } else if (peek(ctx)->type == KW_ENUM) {
+        advance(ctx);
+        ti = spl_type_enum(&ctx->tctx, tname);
+    } else if (peek(ctx)->type == KW_UNION) {
+        advance(ctx);
+        ti = spl_type_union(&ctx->tctx, tname);
+    }
+
+    if (ti >= 0) {
+        if (parent_type_idx >= 0)
+            spl_type_add_nested(&ctx->tctx, parent_type_idx, tname, ti);
+
+        /* Register nested type names inside the body */
+        if (peek(ctx)->type == TOK_L_BRACE) {
+            int saved_current = ctx->tctx.current_type_idx;
+            ctx->tctx.current_type_idx = ti;
+            int depth = 1;
+            advance(ctx); /* { */
+            while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+                spl_tok_type_t tt = peek(ctx)->type;
+                if (tt == TOK_L_BRACE) {
+                    depth++;
+                    advance(ctx);
+                } else if (tt == TOK_R_BRACE) {
+                    depth--;
+                    if (depth == 0)
+                        break;
+                    advance(ctx);
+                } else if (tt == KW_TYPE && depth == 1) {
+                    pre_register_type_decl(ctx);
+                } else if (tt == TOK_EOF) {
+                    break;
+                } else {
+                    advance(ctx);
+                }
+            }
+            if (peek(ctx)->type == TOK_R_BRACE)
+                advance(ctx);
+            ctx->tctx.current_type_idx = saved_current;
+        }
+    }
+
+    skip_nl(ctx);
+    if (peek(ctx)->type == TOK_SEMICOLON)
+        advance(ctx);
+}
+
+/* Pre-register a function name and signature, skip the body */
+static void pre_register_fn_decl(spl_comp_t *ctx, int is_extern) {
+    advance(ctx);
+    skip_nl(ctx);
+    spl_tok_t *fname_tok = advance(ctx);
+    char fn_name[256];
+    spl_tok_copy_name(fname_tok, fn_name, sizeof(fn_name));
+    skip_nl(ctx);
+    if (!expect(ctx, TOK_L_PAREN))
+        return;
+
+    char pnames[MAX_PARAMS][256];
+    int ptypes[MAX_PARAMS];
+    int nparams = parse_params_decl(ctx, pnames, ptypes);
+    skip_nl(ctx);
+
+    int ret_type_idx = spl_type_basic(&ctx->tctx, SPL_VOID);
+    if (peek(ctx)->type != TOK_SEMICOLON && peek(ctx)->type != TOK_L_BRACE) {
+        ret_type_idx = spl_type_parse(&ctx->tctx, ctx);
+        if (ret_type_idx < 0)
+            ret_type_idx = spl_type_basic(&ctx->tctx, SPL_VOID);
+        skip_nl(ctx);
+    }
+
+    if (is_extern) {
+        spl_declare_func(ctx, fn_name, ret_type_idx, nparams, 1, 0);
+        spl_ensure_native(ctx, fn_name);
+        if (peek(ctx)->type == TOK_SEMICOLON)
+            advance(ctx);
+        return;
+    }
+
+    if (peek(ctx)->type == TOK_SEMICOLON) {
+        advance(ctx);
+        return;
+    }
+
+    skip_nl(ctx);
+
+    if (peek(ctx)->type == TOK_L_BRACE) {
+        skip_fn_body(ctx);
+    }
+
+    skip_nl(ctx);
+    if (peek(ctx)->type == TOK_SEMICOLON)
+        advance(ctx);
+}
+
 /* ============================================================
  * Parse top-level program
  * ============================================================ */
 
 void spl_parse_prog(spl_comp_t *ctx) {
-    while (peek(ctx)->type != TOK_EOF) {
+    /* Pass 0: Pre-register all type names, function signatures, and variables */
+    {
+        usize saved = ctx->tok_idx;
+        while (!ctx->has_error && peek(ctx)->type != TOK_EOF) {
+            skip_nl(ctx);
+            if (peek(ctx)->type == TOK_EOF)
+                break;
+
+            switch (peek(ctx)->type) {
+            case KW_TYPE:
+                pre_register_type_decl(ctx);
+                break;
+            case KW_FN:
+                pre_register_fn_decl(ctx, 0);
+                break;
+            case KW_PUB: {
+                advance(ctx);
+                skip_nl(ctx);
+                if (peek(ctx)->type == KW_FN)
+                    pre_register_fn_decl(ctx, 0);
+                else if (peek(ctx)->type == KW_TYPE)
+                    pre_register_type_decl(ctx);
+                break;
+            }
+            case TOK_AT:
+            case TOK_SHARP: {
+                int tt = peek(ctx)->type;
+                advance(ctx);
+                skip_nl(ctx);
+                if (tt == TOK_AT) {
+                    if (peek(ctx)->type == KW_EXTERN) {
+                        advance(ctx);
+                        skip_nl(ctx);
+                        if (peek(ctx)->type == TOK_L_PAREN) {
+                            advance(ctx);
+                            skip_nl(ctx);
+                            advance(ctx);
+                            skip_nl(ctx);
+                            if (peek(ctx)->type == TOK_R_PAREN)
+                                advance(ctx);
+                        }
+                    }
+                } else {
+                    if (peek(ctx)->type == TOK_L_BRACKET) {
+                        advance(ctx);
+                        while (peek(ctx)->type != TOK_R_BRACKET && peek(ctx)->type != TOK_EOF)
+                            advance(ctx);
+                        if (peek(ctx)->type == TOK_R_BRACKET)
+                            advance(ctx);
+                    }
+                }
+                skip_nl(ctx);
+                if (peek(ctx)->type == KW_FN)
+                    pre_register_fn_decl(ctx, 1);
+                break;
+            }
+            default:
+                /* Skip unrecognized tokens (stmts, etc.) */
+                advance(ctx);
+                break;
+            }
+        }
+        ctx->tok_idx = saved;
+    }
+
+    /* Pass 1: Fill all bodies */
+    while (!ctx->has_error && peek(ctx)->type != TOK_EOF) {
         skip_nl(ctx);
         if (peek(ctx)->type == TOK_EOF)
             break;
@@ -487,7 +710,6 @@ void spl_parse_prog(spl_comp_t *ctx) {
             advance(ctx); /* @ or # */
             skip_nl(ctx);
             if (tt == TOK_AT) {
-                /* @extern(vm) fn ... */
                 if (peek(ctx)->type == KW_EXTERN) {
                     advance(ctx); /* extern */
                     skip_nl(ctx);
@@ -501,9 +723,8 @@ void spl_parse_prog(spl_comp_t *ctx) {
                     }
                 }
             } else {
-                /* #[extern("vm")] fn ... (legacy) */
                 if (peek(ctx)->type == TOK_L_BRACKET) {
-                    advance(ctx); /* [ */
+                    advance(ctx);
                     while (peek(ctx)->type != TOK_R_BRACKET && peek(ctx)->type != TOK_EOF)
                         advance(ctx);
                     if (peek(ctx)->type == TOK_R_BRACKET)
@@ -524,4 +745,9 @@ void spl_parse_prog(spl_comp_t *ctx) {
         }
         }
     }
+
+    /* Recompute all type layouts now that forward references are resolved */
+    for (int i = 0; i < (int)vec_size(ctx->tctx.types); i++) {
+        spl_type_compute_layout(&ctx->tctx, i);
+    }
 }

stage1/spl_stmt.c

@@ -9,7 +9,8 @@
  * ============================================================ */
 
 static void parse_ret_stmt(spl_comp_t *ctx) {
-    advance(ctx); /* ret */
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "return statement");
+    spl_tok_t *ret_tok = advance(ctx); /* ret */
     skip_nl(ctx);
 
     /* Before returning, execute all pending defers from innermost scope outward */
@@ -23,7 +24,14 @@ static void parse_ret_stmt(spl_comp_t *ctx) {
         emit_return(&ctx->emit, &ctx->tctx, ctx->current_ret_type_idx);
     } else {
         spl_expr_result_t val = spl_parse_expr(ctx, PREC_MIN);
-        (void)val;
+        int void_ty = spl_type_basic(&ctx->tctx, SPL_VOID);
+        if (ctx->current_ret_type_idx == void_ty) {
+            spl_comp_err_tok(ctx, ret_tok, "cannot return a value from a void function");
+            return;
+        } else if (val.type_idx == void_ty) {
+            spl_comp_err_tok(ctx, ret_tok, "expected return value");
+            return;
+        }
         spl_emit_ret(ctx, ctx->current_ret_type_idx);
     }
     if (peek(ctx)->type == TOK_SEMICOLON)
@@ -41,6 +49,7 @@ static void parse_var_decl(spl_comp_t *ctx, int is_const) {
     spl_tok_t *name_tok = advance(ctx);
     char vname[256];
     spl_tok_copy_name(name_tok, vname, sizeof(vname));
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "variable '%s'", vname);
 
     int var_type_idx = -1;
     int has_init = 0;
@@ -123,14 +132,33 @@ void spl_parse_block(spl_comp_t *ctx) {
         advance(ctx); /* { */
         spl_push_scope(ctx);
 
-        while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+        while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
             spl_parse_stmt(ctx);
             skip_nl(ctx);
         }
 
+        /* Error recovery: skip to matching } if has_error caused early exit */
+        if (ctx->has_error) {
+            int depth = 1;
+            while (depth > 0 && ctx->tok_idx < vec_size(ctx->toks)) {
+                spl_tok_type_t tt = peek(ctx)->type;
+                if (tt == TOK_L_BRACE)
+                    depth++;
+                else if (tt == TOK_R_BRACE) {
+                    depth--;
+                    if (depth == 0)
+                        break;
+                } else if (tt == TOK_EOF)
+                    break;
+                advance(ctx);
+            }
+            if (peek(ctx)->type == TOK_R_BRACE)
+                advance(ctx);
+        }
+
         spl_emit_defer_epilogue(ctx, ctx->scope_depth);
         spl_pop_scope(ctx);
-        if (peek(ctx)->type == TOK_R_BRACE)
+        if (!ctx->has_error && peek(ctx)->type == TOK_R_BRACE)
             advance(ctx);
     } else {
         /* Single statement */
@@ -155,7 +183,7 @@ spl_expr_result_t spl_parse_block_expr(spl_comp_t *ctx) {
     spl_expr_result_t result = {0}; /* void by default */
 
     skip_nl(ctx);
-    while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+    while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
         if (peek(ctx)->type == TOK_SEMICOLON || peek(ctx)->type == TOK_ENDLINE) {
             advance(ctx);
             skip_nl(ctx);
@@ -175,6 +203,7 @@ spl_expr_result_t spl_parse_block_expr(spl_comp_t *ctx) {
             result = (spl_expr_result_t){0};
         } else {
             /* Expression — look ahead for assignment */
+            usize before = ctx->tok_idx;
             int is_assign = lookahead_is_assign(ctx);
             int saved_addr = ctx->addr_of_mode;
             if (is_assign)
@@ -182,6 +211,14 @@ spl_expr_result_t spl_parse_block_expr(spl_comp_t *ctx) {
             spl_expr_result_t expr = spl_parse_expr(ctx, PREC_MIN);
             ctx->addr_of_mode = saved_addr;
 
+            /* Safety: if no token was consumed, advance to prevent infinite loop */
+            if (ctx->tok_idx == before) {
+                advance(ctx);
+                result = (spl_expr_result_t){0};
+                skip_nl(ctx);
+                continue;
+            }
+
             skip_nl(ctx);
             if (peek(ctx)->type == TOK_SEMICOLON || peek(ctx)->type == TOK_ENDLINE) {
                 /* Expression statement: drop value, consume ; */
@@ -201,7 +238,8 @@ spl_expr_result_t spl_parse_block_expr(spl_comp_t *ctx) {
 
     spl_emit_defer_epilogue(ctx, ctx->scope_depth);
     spl_pop_scope(ctx);
-    expect(ctx, TOK_R_BRACE);
+    if (!expect(ctx, TOK_R_BRACE))
+        return result;
     return result;
 }
 
@@ -211,6 +249,7 @@ spl_expr_result_t spl_parse_block_expr(spl_comp_t *ctx) {
 
 static void parse_if_stmt(spl_comp_t *ctx) {
     advance(ctx); /* if */
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "if statement");
     skip_nl(ctx);
     spl_expr_result_t cond = spl_parse_expr(ctx, PREC_MIN);
     (void)cond;
@@ -269,6 +308,7 @@ static void loop_exit(spl_comp_t *ctx, spl_loop_save_t *save) {
 
 static void parse_while_stmt(spl_comp_t *ctx) {
     advance(ctx); /* while */
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "while statement");
     skip_nl(ctx);
 
     spl_loop_save_t save;
@@ -301,6 +341,7 @@ static void parse_loop_stmt(spl_comp_t *ctx) {
 
 static void parse_for_stmt(spl_comp_t *ctx) {
     advance(ctx); /* for */
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "for statement");
     skip_nl(ctx);
 
     /* Parse the iteration expression(s) */
@@ -357,7 +398,7 @@ static void parse_for_stmt(spl_comp_t *ctx) {
 
         /* Exit: patch bz, drop end */
         emit_patch_here(&ctx->emit, bz_addr);
-        emit_drop(&ctx->emit);
+        emit_drop(&ctx->emit); /* [] */
 
         spl_emit_defer_epilogue(ctx, ctx->scope_depth);
         spl_pop_scope(ctx);
@@ -487,9 +528,10 @@ static void parse_for_stmt(spl_comp_t *ctx) {
  * ============================================================ */
 
 static void parse_break_stmt(spl_comp_t *ctx) {
-    advance(ctx); /* break */
+    spl_tok_t *tok = advance(ctx); /* break */
     if (!ctx->in_loop) {
-        spl_comp_error(ctx, "break outside loop");
+        spl_comp_err_tok(ctx, tok, "break outside loop");
+        return;
     }
     /* Emit JMP with placeholder, add to patch list */
     spl_val_t addr = emit_jmp_here(&ctx->emit);
@@ -504,9 +546,10 @@ static void parse_break_stmt(spl_comp_t *ctx) {
 }
 
 static void parse_continue_stmt(spl_comp_t *ctx) {
-    advance(ctx); /* continue */
+    spl_tok_t *tok = advance(ctx); /* continue */
     if (!ctx->in_loop) {
-        spl_comp_error(ctx, "continue outside loop");
+        spl_comp_err_tok(ctx, tok, "continue outside loop");
+        return;
     }
     /* Emit JMP with relative offset to continue_target */
     spl_val_t here = vec_size(ctx->prog.insns);
@@ -559,16 +602,100 @@ static void parse_match_value_pattern(spl_comp_t *ctx, int val_offset) {
     spl_emit_match_value_cmp(ctx, val_offset);
 }
 
-/* Parse enum variant data bindings: (name1, name2, ...)
+/* Parse enum variant data bindings:
+ *   [var]              — global binding: var = entire payload struct
+ *   [.field = var, ...] — field-by-name binding
+ *   (name1, name2, ...) — (legacy) positional field binding
  * Declares local variables and loads corresponding field data
  * from the matched value's data area (offset 4+).
  * Sets *scope_pushed = 1 if bindings declared. */
 static void parse_match_enum_bindings(spl_comp_t *ctx, int enum_type_idx, int variant_item_idx,
                                       int val_offset, int *scope_pushed) {
+    if (peek(ctx)->type == TOK_L_BRACKET) {
+        /* ---- New syntax: [var] or [.field = var, ...] ---- */
+        advance(ctx); /* [ */
+        skip_nl(ctx);
+        if (peek(ctx)->type == TOK_R_BRACKET) {
+            if (!expect(ctx, TOK_R_BRACKET))
+                return;
+        }
+
+        spl_push_scope(ctx);
+        *scope_pushed = 1;
+
+        spl_type_item_t *var_item = spl_type_item_at(&ctx->tctx, enum_type_idx, variant_item_idx);
+        int data_type_idx = var_item ? var_item->enum_field.type_idx : -1;
+
+        if (peek(ctx)->type == TOK_DOT) {
+            /* [.field = var, ...] — field-by-name binding */
+            for (;;) {
+                advance(ctx); /* . */
+                spl_tok_t *ftok = advance(ctx);
+                char fname[256];
+                spl_tok_copy_name(ftok, fname, sizeof(fname));
+                skip_nl(ctx);
+
+                if (peek(ctx)->type == TOK_ASSIGN)
+                    advance(ctx);
+                skip_nl(ctx);
+
+                spl_tok_t *vtok = advance(ctx);
+                char vname[256];
+                spl_tok_copy_name(vtok, vname, sizeof(vname));
+
+                int field_type = -1;
+                usize field_off = 0;
+                if (data_type_idx >= 0 && spl_type_kind(&ctx->tctx, data_type_idx) == TYPE_STRUCT) {
+                    spl_type_item_vec_t *data_items = spl_type_items(&ctx->tctx, data_type_idx);
+                    vec_for(*data_items, di) {
+                        spl_type_item_t *fit = &vec_at(*data_items, di);
+                        if (fit->item_kind == ITEM_FIELD && strcmp(fit->name, fname) == 0) {
+                            field_type = fit->aggregate_field.type_idx;
+                            field_off = fit->aggregate_field.offset;
+                            break;
+                        }
+                    }
+                }
+                if (field_type < 0) {
+                    spl_comp_err_tok(ctx, ftok, "unknown field '%s' in enum variant", fname);
+                    break;
+                }
+
+                int boffset = spl_declare_var(ctx, vname, field_type, 0);
+                emit_load_to_var(&ctx->emit, &ctx->tctx, val_offset, ENUM_TAG_SIZE + field_off,
+                                 field_type, boffset);
+
+                skip_nl(ctx);
+                if (peek(ctx)->type == TOK_COMMA) {
+                    advance(ctx);
+                    skip_nl(ctx);
+                    continue;
+                }
+                break;
+            }
+        } else {
+            /* [var] — global binding: entire payload as one variable */
+            spl_tok_t *vtok = advance(ctx);
+            char vname[256];
+            spl_tok_copy_name(vtok, vname, sizeof(vname));
+
+            if (data_type_idx >= 0) {
+                int boffset = spl_declare_var(ctx, vname, data_type_idx, 0);
+                emit_load_to_var(&ctx->emit, &ctx->tctx, val_offset, ENUM_TAG_SIZE, data_type_idx,
+                                 boffset);
+            }
+        }
+
+        if (!expect(ctx, TOK_R_BRACKET))
+            return;
+        return;
+    }
+
+    /* ---- Legacy syntax: (name1, name2, ...)  ---- */
     advance(ctx); /* ( */
     skip_nl(ctx);
     if (peek(ctx)->type == TOK_R_PAREN) {
-        expect(ctx, TOK_R_PAREN);
+        if (!expect(ctx, TOK_R_PAREN))
             return;
     }
 
@@ -626,7 +753,8 @@ static void parse_match_enum_bindings(spl_comp_t *ctx, int enum_type_idx, int va
         emit_load_to_var(&ctx->emit, &ctx->tctx, val_offset, ENUM_TAG_SIZE, data_type_idx, boffset);
     }
 
-    expect(ctx, TOK_R_PAREN);
+    if (!expect(ctx, TOK_R_PAREN))
+        return;
 }
 
 /* ============================================================
@@ -640,6 +768,7 @@ static void parse_match_enum_bindings(spl_comp_t *ctx, int enum_type_idx, int va
 
 static void parse_match_stmt(spl_comp_t *ctx) {
     advance(ctx); /* match */
+    snprintf(ctx->parse_context, sizeof(ctx->parse_context), "match expression");
     skip_nl(ctx);
 
     spl_expr_result_t expr = spl_parse_expr(ctx, PREC_MIN);
@@ -658,7 +787,7 @@ static void parse_match_stmt(spl_comp_t *ctx) {
         enum_type_idx = spl_type_elem_type(&ctx->tctx, type_idx);
     } else if (!(type_idx >= 0 && spl_type_kind(&ctx->tctx, type_idx) == TYPE_BASIC &&
                  spl_type_is_integer(spl_type_basic_type(&ctx->tctx, type_idx)))) {
-        spl_comp_error(ctx, "match expression must be an enum or integer type");
+        spl_comp_err_tok(ctx, peek(ctx), "match expression must be an enum or integer type");
         return;
     }
 
@@ -680,7 +809,7 @@ static void parse_match_stmt(spl_comp_t *ctx) {
     int n_jmps = 0;
 
     skip_nl(ctx);
-    while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
+    while (!ctx->has_error && peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
         skip_nl(ctx);
         if (peek(ctx)->type == TOK_COMMA) {
             advance(ctx);
@@ -708,7 +837,7 @@ static void parse_match_stmt(spl_comp_t *ctx) {
                     if (ctx->has_error)
                         break;
                     skip_nl(ctx);
-                    if (peek(ctx)->type == TOK_L_PAREN) {
+                    if (peek(ctx)->type == TOK_L_PAREN || peek(ctx)->type == TOK_L_BRACKET) {
                         has_parens = 1;
                         break; /* bindings → must be last in fallthrough group */
                     }
@@ -781,7 +910,8 @@ static void parse_match_stmt(spl_comp_t *ctx) {
         skip_nl(ctx);
     }
 
-    expect(ctx, TOK_R_BRACE);
+    if (!expect(ctx, TOK_R_BRACE))
+        return;
 
     /* Patch all JMPs to end */
     for (int i = 0; i < n_jmps; i++)
@@ -815,7 +945,8 @@ static void parse_extern_decl(spl_comp_t *ctx) {
         }
     } else {
         /* #[extern("vm")] fn ... (legacy) */
-        expect(ctx, TOK_L_BRACKET);
+        if (!expect(ctx, TOK_L_BRACKET))
+            return;
         while (peek(ctx)->type != TOK_R_BRACKET && peek(ctx)->type != TOK_EOF)
             advance(ctx);
         if (peek(ctx)->type == TOK_R_BRACKET)
@@ -832,7 +963,8 @@ static void parse_extern_decl(spl_comp_t *ctx) {
         spl_tok_copy_name(fname_tok, fn_name, sizeof(fn_name));
 
         skip_nl(ctx);
-        expect(ctx, TOK_L_PAREN);
+        if (!expect(ctx, TOK_L_PAREN))
+            return;
 
         /* Count params (we don't store them for extern) */
         int nparams = 0;
@@ -860,7 +992,8 @@ static void parse_extern_decl(spl_comp_t *ctx) {
                 break;
             }
         }
-        expect(ctx, TOK_R_PAREN);
+        if (!expect(ctx, TOK_R_PAREN))
+            return;
         skip_nl(ctx);
 
         /* Return type */
@@ -953,21 +1086,27 @@ void spl_parse_stmt(spl_comp_t *ctx) {
         parse_ret_stmt(ctx);
         break;
     case KW_VAR:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "variable declaration");
         parse_var_decl(ctx, 0);
         break;
     case KW_CONST:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "constant declaration");
         parse_var_decl(ctx, 1);
         break;
     case KW_IF:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "if statement");
         parse_if_stmt(ctx);
         break;
     case KW_WHILE:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "while statement");
         parse_while_stmt(ctx);
         break;
     case KW_LOOP:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "loop statement");
         parse_loop_stmt(ctx);
         break;
     case KW_FOR:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "for statement");
         parse_for_stmt(ctx);
         break;
     case KW_BREAK:
@@ -980,6 +1119,7 @@ void spl_parse_stmt(spl_comp_t *ctx) {
         parse_defer_stmt(ctx);
         break;
     case KW_MATCH:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "match expression");
         parse_match_stmt(ctx);
         break;
     case KW_TYPE:
@@ -1009,6 +1149,7 @@ void spl_parse_stmt(spl_comp_t *ctx) {
         parse_extern_decl(ctx);
         break;
     default:
+        snprintf(ctx->parse_context, sizeof(ctx->parse_context), "expression statement");
         parse_expr_stmt(ctx);
         break;
     }

stage1/spl_type.c

@@ -304,6 +304,32 @@ int spl_type_alias(spl_type_ctx_t *tctx, const char *name, int target_type_idx)
     return idx;
 }
 
+int spl_type_fn(spl_type_ctx_t *tctx, int params_type_idx, int ret_type_idx) {
+    spl_type_info_t t;
+    memset(&t, 0, sizeof(t));
+    t.kind = TYPE_FN;
+    t.byte_size = sizeof(spl_val_t);
+    t.slot_count = 1;
+    t.resolved = 1;
+    vec_init(t.items);
+
+    spl_type_item_t pi;
+    memset(&pi, 0, sizeof(pi));
+    pi.item_kind = ITEM_FIELD;
+    pi.aggregate_field.type_idx = params_type_idx;
+    pi.aggregate_field.offset = 0;
+    vec_push(t.items, pi);
+
+    spl_type_item_t ri;
+    memset(&ri, 0, sizeof(ri));
+    ri.item_kind = ITEM_FIELD;
+    ri.aggregate_field.type_idx = ret_type_idx;
+    ri.aggregate_field.offset = sizeof(spl_val_t);
+    vec_push(t.items, ri);
+
+    return spl_type_add(tctx, t);
+}
+
 /* ============================================================
  * Item management
  * ============================================================ */
@@ -317,6 +343,20 @@ void spl_type_add_field(spl_type_ctx_t *tctx, int type_idx, const char *name, in
     item.aggregate_field.type_idx = field_type_idx;
     item.aggregate_field.offset = 0;
     vec_push(t->items, item);
+    /* Adding field after layout was computed → needs recompute */
+    if (t->resolved == 1)
+        t->resolved = 0;
+}
+
+void spl_type_add_var(spl_type_ctx_t *tctx, int type_idx, const char *name, int var_type_idx) {
+    spl_type_info_t *t = &vec_at(tctx->types, type_idx);
+    spl_type_item_t item;
+    memset(&item, 0, sizeof(item));
+    item.name = strdup(name);
+    item.item_kind = ITEM_VAR;
+    item.aggregate_field.type_idx = var_type_idx;
+    item.aggregate_field.offset = 0;
+    vec_push(t->items, item);
 }
 
 void spl_type_add_variant(spl_type_ctx_t *tctx, int type_idx, const char *name, int data_type_idx) {
@@ -328,6 +368,8 @@ void spl_type_add_variant(spl_type_ctx_t *tctx, int type_idx, const char *name,
     item.enum_field.type_idx = data_type_idx;
     item.enum_field.value = vec_size(t->items);
     vec_push(t->items, item);
+    if (t->resolved == 1)
+        t->resolved = 0;
 }
 
 void spl_type_add_method(spl_type_ctx_t *tctx, int type_idx, const char *name, int func_idx) {
@@ -371,14 +413,22 @@ void spl_type_compute_layout(spl_type_ctx_t *tctx, int type_idx) {
     if (type_idx < 0)
         return;
     spl_type_info_t *t = &vec_at(tctx->types, type_idx);
-    if (t->resolved)
+    if (t->resolved == 1)
         return;
+    if (t->resolved == 2) {
+        fprintf(stderr, "error: circular type dependency in '%s'\n", t->name ? t->name : "?");
+        return;
+    }
+
+    t->resolved = 2; /* mark as in-progress */
 
     switch (t->kind) {
     case TYPE_STRUCT: {
         usize offset = 0;
         vec_for(t->items, i) {
             spl_type_item_t *it = &vec_at(t->items, i);
+            if (it->item_kind == ITEM_VAR)
+                continue;
             if (it->item_kind == ITEM_FIELD && it->aggregate_field.type_idx >= 0) {
                 spl_type_compute_layout(tctx, it->aggregate_field.type_idx);
                 spl_type_info_t *ft = &vec_at(tctx->types, it->aggregate_field.type_idx);
@@ -398,6 +448,8 @@ void spl_type_compute_layout(spl_type_ctx_t *tctx, int type_idx) {
         usize max_sz = 0;
         vec_for(t->items, i) {
             spl_type_item_t *it = &vec_at(t->items, i);
+            if (it->item_kind == ITEM_VAR)
+                continue;
             if (it->item_kind == ITEM_FIELD && it->aggregate_field.type_idx >= 0) {
                 spl_type_compute_layout(tctx, it->aggregate_field.type_idx);
                 spl_type_info_t *ft = &vec_at(tctx->types, it->aggregate_field.type_idx);
@@ -519,8 +571,9 @@ usize spl_type_array_len(spl_type_ctx_t *tctx, int type_idx) {
 int spl_type_is_scalar(spl_type_ctx_t *tctx, int type_idx) {
     if (type_idx < 0)
         return 1;
+    type_idx = spl_type_resolve_underlying(tctx, type_idx);
     spl_type_info_t *t = &vec_at(tctx->types, type_idx);
-    if (t->kind == TYPE_BASIC || t->kind == TYPE_PTR)
+    if (t->kind == TYPE_BASIC || t->kind == TYPE_PTR || t->kind == TYPE_FN)
         return 1;
     if (t->kind == TYPE_ENUM) {
         vec_for(t->items, i) {
@@ -560,6 +613,7 @@ int spl_type_resolve_underlying(spl_type_ctx_t *tctx, int type_idx) {
 spl_type_t spl_type_emit_type(spl_type_ctx_t *tctx, int type_idx) {
     if (type_idx < 0)
         return SPL_I32;
+    type_idx = spl_type_resolve_underlying(tctx, type_idx);
     spl_type_info_t *t = &vec_at(tctx->types, type_idx);
     if (t->kind == TYPE_BASIC)
         return t->basic_type;
@@ -575,7 +629,14 @@ spl_type_t spl_type_emit_type(spl_type_ctx_t *tctx, int type_idx) {
     return SPL_PTR;
 }
 
+#define TYPE_STR_BUF_COUNT 8
+#define TYPE_STR_BUF_SIZE 64
+
 const char *spl_type_str(spl_type_ctx_t *tctx, int type_idx) {
+    static char b[TYPE_STR_BUF_COUNT][TYPE_STR_BUF_SIZE];
+    static int bi = 0;
+    int my = (bi++) % TYPE_STR_BUF_COUNT;
+
     if (type_idx < 0)
         return "<null>";
     spl_type_info_t *t = &vec_at(tctx->types, type_idx);
@@ -616,28 +677,26 @@ const char *spl_type_str(spl_type_ctx_t *tctx, int type_idx) {
             return "<basic>";
         }
     }
-    case TYPE_PTR: {
+    case TYPE_PTR:
-        static char buf[64];
+        snprintf(b[my], TYPE_STR_BUF_SIZE, "*%s",
-        snprintf(buf, sizeof(buf), "*%s", spl_type_str(tctx, spl_type_elem_type(tctx, type_idx)));
-        return buf;
-    }
-    case TYPE_ARRAY: {
-        static char buf[64];
-        snprintf(buf, sizeof(buf), "[%zu]%s", spl_type_array_len(tctx, type_idx),
                  spl_type_str(tctx, spl_type_elem_type(tctx, type_idx)));
-        return buf;
+        return b[my];
-    }
+    case TYPE_ARRAY:
-    case TYPE_SLICE: {
+        snprintf(b[my], TYPE_STR_BUF_SIZE, "[%zu]%s", spl_type_array_len(tctx, type_idx),
-        static char buf[64];
+                 spl_type_str(tctx, spl_type_elem_type(tctx, type_idx)));
-        snprintf(buf, sizeof(buf), "[]%s", spl_type_str(tctx, spl_type_elem_type(tctx, type_idx)));
+        return b[my];
-        return buf;
+    case TYPE_SLICE:
-    }
+        snprintf(b[my], TYPE_STR_BUF_SIZE, "[]%s",
+                 spl_type_str(tctx, spl_type_elem_type(tctx, type_idx)));
+        return b[my];
     case TYPE_STRUCT:
     case TYPE_UNION:
     case TYPE_ENUM:
         return t->name ? t->name : "<?>";
     case TYPE_NAME:
         return t->name ? t->name : "<alias>";
+    case TYPE_FN:
+        return "fn";
     default:
         return "<?>";
     }
@@ -766,13 +825,13 @@ int spl_type_parse(spl_type_ctx_t *tctx, struct spl_comp *ctx) {
 
         int len_val;
         if (!spl_parse_int_literal(ctx, &len_val)) {
-            spl_comp_error(ctx, "expected array length");
+            spl_comp_err_tok(ctx, peek(ctx), "expected array length");
             return -1;
         }
         usize len = (usize)len_val;
 
         if (vec_at(ctx->toks, ctx->tok_idx).type != TOK_R_BRACKET) {
-            spl_comp_error(ctx, "expected ']'");
+            spl_comp_err_tok(ctx, peek(ctx), "expected ']'");
             return -1;
         }
         ctx->tok_idx++;
@@ -839,6 +898,39 @@ int spl_type_parse(spl_type_ctx_t *tctx, struct spl_comp *ctx) {
         return ti;
     }
 
+    /* Inline function type: fn(params...) rettype */
+    if (tok->type == KW_FN) {
+        ctx->tok_idx++;
+        if (!expect(ctx, TOK_L_PAREN))
+            return -1;
+
+        /* Parse comma-separated parameter types */
+        int param_types[64]; /* max 64 params */
+        int nparams = 0;
+        if (peek(ctx)->type != TOK_R_PAREN) {
+            for (;;) {
+                int pt = spl_type_parse(tctx, ctx);
+                if (pt >= 0 && nparams < 64)
+                    param_types[nparams++] = pt;
+                if (peek(ctx)->type == TOK_COMMA) {
+                    advance(ctx);
+                    continue;
+                }
+                break;
+            }
+        }
+        if (!expect(ctx, TOK_R_PAREN))
+            return -1;
+
+        int ret_type = spl_type_parse(tctx, ctx);
+        if (ret_type < 0)
+            ret_type = spl_type_basic(tctx, SPL_VOID);
+
+        /* Store param types in a synthetic array type (slot 0 = count, slot 1..N = params) */
+        int params_arr = spl_type_array(tctx, spl_type_basic(tctx, SPL_USIZE), nparams);
+        return spl_type_fn(tctx, params_arr, ret_type);
+    }
+
     /* Identifier: basic type or named type */
     if (tok->type == TOK_IDENT || ((int)tok->type >= (int)KW_AS && (int)tok->type <= (int)KW_ANY)) {
         const char *name = tok->lexeme;
@@ -856,6 +948,14 @@ int spl_type_parse(spl_type_ctx_t *tctx, struct spl_comp *ctx) {
         id_buf[cplen] = '\0';
 
         int found = spl_type_resolve(tctx, id_buf);
+        if (found < 0 && tctx->current_type_idx >= 0) {
+            const char *cur_type_name = spl_type_name(tctx, tctx->current_type_idx);
+            if (cur_type_name) {
+                char qualified[512];
+                snprintf(qualified, sizeof(qualified), "%s.%s", cur_type_name, id_buf);
+                found = spl_type_resolve(tctx, qualified);
+            }
+        }
         if (found >= 0) {
             ctx->tok_idx++;
 
@@ -900,10 +1000,11 @@ int spl_type_parse(spl_type_ctx_t *tctx, struct spl_comp *ctx) {
             return ti;
         }
 
-        spl_comp_error(ctx, "unknown type '%s'", id_buf);
+        spl_comp_err_tok(ctx, tok, "unknown type '%s'", id_buf);
+        ctx->tok_idx++;
         return -1;
     }
 
-    spl_comp_error(ctx, "expected type");
+    spl_comp_err_tok(ctx, peek(ctx), "expected type");
     return -1;
 }

stage1/spl_type.h

@@ -18,6 +18,7 @@ typedef enum {
     TYPE_UNION,
     TYPE_ENUM,
     TYPE_NAME,
+    TYPE_FN,
     TYPE_COUNT,
 } spl_type_kind_t;
 
@@ -32,6 +33,7 @@ typedef enum {
     ITEM_VARIANT,     /* enum_field       : enum variant      */
     ITEM_METHOD,      /* method           : type method       */
     ITEM_NESTED_TYPE, /* nested_type      : child type decl   */
+    ITEM_VAR,         /* aggregate_field  : type-level var      */
 } spl_type_item_kind_t;
 
 /* ============================================================
@@ -122,12 +124,14 @@ int spl_type_struct(spl_type_ctx_t *tctx, const char *name);
 int spl_type_union(spl_type_ctx_t *tctx, const char *name);
 int spl_type_enum(spl_type_ctx_t *tctx, const char *name);
 int spl_type_alias(spl_type_ctx_t *tctx, const char *name, int target_type_idx);
+int spl_type_fn(spl_type_ctx_t *tctx, int params_type_idx, int ret_type_idx);
 
 /* ============================================================
  * Item management — add members to aggregate types
  * ============================================================ */
 
 void spl_type_add_field(spl_type_ctx_t *tctx, int type_idx, const char *name, int field_type_idx);
+void spl_type_add_var(spl_type_ctx_t *tctx, int type_idx, const char *name, int var_type_idx);
 void spl_type_add_variant(spl_type_ctx_t *tctx, int type_idx, const char *name, int data_type_idx);
 void spl_type_add_method(spl_type_ctx_t *tctx, int type_idx, const char *name, int func_idx);
 void spl_type_add_nested(spl_type_ctx_t *tctx, int parent_idx, const char *name,