kit

parse_type.c (61640B)

---

 /* parse_type.c — decl-specs, struct/union/enum, declarators,
  * __attribute__ parsing. */
 
 #include "parse/parse_priv.h"
 
 /* ============================================================
  * Type helpers
  * ============================================================ */
 
 static const Type* ty_int(Parser* p) { return type_prim(p->pool, TY_INT); }
 static const Type* ty_size_t(Parser* p) {
   return c_abi_size_type(p->abi, p->pool);
 }
 
 /* __int128 is a 16-byte scalar that the ABI, runtime ti3 helpers, and the
  * HAS_INT128 capability only support on 64-bit targets (matching GCC/Clang,
  * which reject __int128 on 32-bit architectures). Gate on the target pointer
  * width: ptr_size == 8 means 64-bit (rv64/x64/aa64) and int128 is available;
  * a 32-bit target (rv32, with a 4-byte pointer) has no working int128. */
 static int target_has_int128(Parser* p) {
   return kit_compiler_target_spec(p->c).ptr_size == 8;
 }
 
 /* ============================================================
  * GNU __attribute__ (Phase 1 — parse + carry; no semantic wire-up)
  * ============================================================ */
 
 static const struct {
   const char* name;
   AttrKind kind;
   AttrArgShape shape;
 } kAttrTable[] = {
     {"packed", ATTR_PACKED, AS_NONE},
     {"aligned", ATTR_ALIGNED, AS_INT_OPT},
     {"section", ATTR_SECTION, AS_STRING},
     {"used", ATTR_USED, AS_NONE},
     {"noreturn", ATTR_NORETURN, AS_NONE},
     {"alias", ATTR_ALIAS, AS_STRING},
     {"weak", ATTR_WEAK, AS_NONE},
     {"visibility", ATTR_VISIBILITY, AS_STRING},
     {"always_inline", ATTR_ALWAYS_INLINE, AS_NONE},
     {"noinline", ATTR_NOINLINE, AS_NONE},
     {"unused", ATTR_UNUSED, AS_NONE},
     {"deprecated", ATTR_DEPRECATED, AS_OPAQUE},
     {"warn_unused_result", ATTR_WARN_UNUSED_RESULT, AS_NONE},
     {"format", ATTR_FORMAT, AS_FORMAT},
     {"nonnull", ATTR_NONNULL, AS_OPAQUE},
     {"returns_nonnull", ATTR_RETURNS_NONNULL, AS_NONE},
     {"pure", ATTR_PURE, AS_NONE},
     {"const", ATTR_CONST, AS_NONE},
     {"malloc", ATTR_MALLOC, AS_OPAQUE},
     {"nothrow", ATTR_NOTHROW, AS_NONE},
     {"leaf", ATTR_LEAF, AS_NONE},
     {"cold", ATTR_COLD, AS_NONE},
     {"hot", ATTR_HOT, AS_NONE},
     {"constructor", ATTR_CONSTRUCTOR, AS_INT_OPT},
     {"destructor", ATTR_DESTRUCTOR, AS_INT_OPT},
     {"cleanup", ATTR_CLEANUP, AS_IDENT},
     {"mode", ATTR_MODE, AS_IDENT},
     {"vector_size", ATTR_VECTOR_SIZE, AS_INT},
     {"transparent_union", ATTR_TRANSPARENT_UNION, AS_NONE},
     {"gnu_inline", ATTR_GNU_INLINE, AS_NONE},
     {"fallthrough", ATTR_FALLTHROUGH, AS_NONE},
     {"sentinel", ATTR_SENTINEL, AS_OPAQUE},
     {"no_instrument_function", ATTR_NO_INSTRUMENT_FUNCTION, AS_NONE},
     {"no_sanitize", ATTR_NO_SANITIZE, AS_OPAQUE},
     {"import_module", ATTR_IMPORT_MODULE, AS_STRING},
     {"import_name", ATTR_IMPORT_NAME, AS_STRING},
 };
 
 static SrcLoc tok_loc(Parser* p, const Tok* t) {
   return pp_materialize_loc(p->pp, t->loc);
 }
 
 static void attr_canon_range(const char* s, size_t len, const char** out_p,
                              size_t* out_len);
 
 static int accept_kw(Parser* p, CKw k) {
   if (is_kw(p, &p->cur, k)) {
     advance(p);
     return 1;
   }
   return 0;
 }
 
 static int attr_sym_canon_eq(Parser* p, Sym sym, const char* want) {
   KitSlice sym_sl = kit_sym_str(p->pool->c, sym);
   size_t len = sym_sl.len;
   const char* s = sym_sl.s;
   const char* cs;
   size_t clen;
   if (!s) return 0;
   attr_canon_range(s, len, &cs, &clen);
   return kit_slice_eq_cstr((KitSlice){.s = cs, .len = clen}, want);
 }
 
 static const Type* attrs_apply_type_mode(Parser* p, const Type* base,
                                          const Attr* attrs) {
   for (const Attr* a = attrs; a; a = a->next) {
     if (a->kind != ATTR_MODE || a->nargs == 0) continue;
     if (attr_sym_canon_eq(p, a->v.sym, "TI")) {
       const Type* u = type_unqual(p->pool, base);
       int is_unsigned = u && type_is_int(u) && type_is_signed_integer(u) == 0;
       if (!target_has_int128(p)) {
         perr(p, "__int128 is not supported on the target architecture");
       }
       return type_prim(p->pool, is_unsigned ? TY_UINT128 : TY_INT128);
     }
   }
   return base;
 }
 
 int starts_attr(const Parser* p) {
   return p->cur.kind == TOK_IDENT && tok_ident(&p->cur) == p->sym_attribute;
 }
 
 static void skip_balanced_parens(Parser* p);
 
 static int slice_has_prefix(KitSlice s, KitSlice prefix) {
   return s.len >= prefix.len && memcmp(s.s, prefix.s, prefix.len) == 0;
 }
 
 static int starts_darwin_availability(const Parser* p) {
   KitSlice s;
   if (p->cur.kind != TOK_IDENT) return 0;
   s = kit_sym_str(p->pool->c, tok_ident(&p->cur));
   return slice_has_prefix(s, KIT_SLICE_LIT("__AVAILABILITY")) ||
          slice_has_prefix(s, KIT_SLICE_LIT("__API_AVAILABLE")) ||
          slice_has_prefix(s, KIT_SLICE_LIT("__API_DEPRECATED")) ||
          slice_has_prefix(s, KIT_SLICE_LIT("__API_UNAVAILABLE"));
 }
 
 static int starts_asm_label(const Parser* p) {
   return is_kw(p, &p->cur, KW_ASM) || is_kw(p, &p->cur, KW_BUILTIN_ASM);
 }
 
 static void parse_and_discard_darwin_availability(Parser* p) {
   advance(p);
   if (is_punct(&p->cur, '(')) skip_balanced_parens(p);
 }
 
 static Sym parse_asm_label(Parser* p) {
   Sym label = 0;
   advance(p); /* asm / __asm / __asm__ */
   expect_punct(p, '(', "'(' after asm label");
   if (p->cur.kind != TOK_STR) {
     perr(p, "expected string literal in asm label");
   }
   /* Capture the label string for the declarator currently being parsed. For a
    * `register T x __asm__("r10")` local this is the hard register name the
    * variable binds to. Other asm labels (symbol renames) are still effectively
    * ignored by callers that do not consume DeclaratorInfo.asm_label. */
   {
     Tok t = p->cur;
     size_t nlen = 0;
     u8* bytes = decode_string_literal(p, &t, &nlen);
     u32 ilen = (nlen > 0) ? (u32)(nlen - 1) : 0;
     label = kit_sym_intern(p->pool->c,
                            (KitSlice){.s = (const char*)bytes, .len = ilen});
     kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                            bytes, 0);
   }
   do {
     advance(p);
   } while (p->cur.kind == TOK_STR);
   expect_punct(p, ')', "')' after asm label");
   return label;
 }
 
 static void parse_attrs_and_asm_into(Parser* p, Attr** attrs_out,
                                      Attr** local_attrs, Sym* asm_label_out) {
   for (;;) {
     if (starts_attr(p)) {
       if (attrs_out)
         parse_attrs_into(p, attrs_out);
       else
         parse_attrs_into(p, local_attrs);
       continue;
     }
     if (starts_asm_label(p)) {
       Sym label = parse_asm_label(p);
       if (asm_label_out) *asm_label_out = label;
       continue;
     }
     if (starts_darwin_availability(p)) {
       parse_and_discard_darwin_availability(p);
       continue;
     }
     break;
   }
 }
 
 static void parse_and_discard_attrs_or_asm(Parser* p) {
   for (;;) {
     if (starts_attr(p)) {
       parse_and_discard_attributes(p);
       continue;
     }
     if (starts_asm_label(p)) {
       (void)parse_asm_label(p);
       continue;
     }
     if (starts_darwin_availability(p)) {
       parse_and_discard_darwin_availability(p);
       continue;
     }
     break;
   }
 }
 
 static void attr_canon_range(const char* s, size_t len, const char** out_p,
                              size_t* out_len) {
   if (len >= 4 && s[0] == '_' && s[1] == '_' && s[len - 1] == '_' &&
       s[len - 2] == '_') {
     *out_p = s + 2;
     *out_len = len - 4;
     return;
   }
   *out_p = s;
   *out_len = len;
 }
 
 static AttrKind classify_attr(Parser* p, Sym name, AttrArgShape* shape_out) {
   KitSlice name_sl = kit_sym_str(p->pool->c, name);
   size_t len = name_sl.len;
   const char* s = name_sl.s;
   const char* cs;
   size_t clen;
   size_t i;
   if (!s) {
     *shape_out = AS_OPAQUE;
     return ATTR_UNKNOWN;
   }
   attr_canon_range(s, len, &cs, &clen);
   for (i = 0; i < sizeof(kAttrTable) / sizeof(kAttrTable[0]); ++i) {
     const char* tn = kAttrTable[i].name;
     if (kit_slice_eq_cstr((KitSlice){.s = cs, .len = clen}, tn)) {
       *shape_out = kAttrTable[i].shape;
       return kAttrTable[i].kind;
     }
   }
   *shape_out = AS_OPAQUE;
   return ATTR_UNKNOWN;
 }
 
 static void skip_balanced_parens(Parser* p) {
   int depth;
   if (!is_punct(&p->cur, '(')) perr(p, "internal: skip_balanced_parens");
   depth = 1;
   advance(p);
   while (depth > 0) {
     if (p->cur.kind == TOK_EOF) {
       perr(p, "unexpected EOF inside attribute arguments");
     }
     if (is_punct(&p->cur, '('))
       ++depth;
     else if (is_punct(&p->cur, ')')) {
       --depth;
       if (depth == 0) {
         advance(p);
         return;
       }
     }
     advance(p);
   }
 }
 
 static void parse_attr_args(Parser* p, Attr* a, AttrArgShape shape,
                             const char* attr_diag_name) {
   if (!is_punct(&p->cur, '(')) {
     if (shape == AS_NONE || shape == AS_OPTIONAL || shape == AS_INT_OPT ||
         shape == AS_OPAQUE) {
       return;
     }
     perr(p, "attribute '%.*s' expects '(' arguments",
          KIT_SLICE_ARG(kit_slice_cstr(attr_diag_name)));
   }
   switch (shape) {
     case AS_NONE: {
       advance(p); /* '(' */
       if (!accept_punct(p, ')')) {
         perr(p, "attribute '%.*s' takes no arguments",
              KIT_SLICE_ARG(kit_slice_cstr(attr_diag_name)));
       }
       return;
     }
     case AS_OPTIONAL: {
       skip_balanced_parens(p);
       return;
     }
     case AS_INT:
     case AS_INT_OPT: {
       SrcLoc loc;
       advance(p); /* '(' */
       if (is_punct(&p->cur, ')')) {
         if (shape == AS_INT) {
           perr(p, "attribute '%.*s' expects an integer argument",
                KIT_SLICE_ARG(kit_slice_cstr(attr_diag_name)));
         }
         advance(p);
         return;
       }
       loc = tok_loc(p, &p->cur);
       a->v.i = eval_const_int(p, loc);
       if (a->kind == ATTR_ALIGNED && a->v.i > 0 &&
           (((u64)a->v.i & ((u64)a->v.i - 1u)) != 0)) {
         perr(p, "attribute 'aligned' argument must be a power of two");
       }
       a->nargs = 1;
       expect_punct(p, ')', "')' after attribute integer argument");
       return;
     }
     case AS_STRING: {
       advance(p); /* '(' */
       if (p->cur.kind != TOK_STR) {
         perr(p, "attribute '%.*s' expects a string literal",
              KIT_SLICE_ARG(kit_slice_cstr(attr_diag_name)));
       }
       {
         Tok t = p->cur;
         size_t nlen = 0;
         u8* bytes = decode_string_literal(p, &t, &nlen);
         u32 ilen = (nlen > 0) ? (u32)(nlen - 1) : 0;
         a->v.sym = kit_sym_intern(
             p->pool->c, (KitSlice){.s = (const char*)bytes, .len = ilen});
         kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                                bytes, 0);
       }
       a->nargs = 1;
       advance(p);
       expect_punct(p, ')', "')' after attribute string argument");
       return;
     }
     case AS_IDENT: {
       advance(p); /* '(' */
       if (p->cur.kind != TOK_IDENT) {
         perr(p, "attribute '%.*s' expects an identifier",
              KIT_SLICE_ARG(kit_slice_cstr(attr_diag_name)));
       }
       a->v.sym = tok_ident(&p->cur);
       a->nargs = 1;
       advance(p);
       expect_punct(p, ')', "')' after attribute identifier argument");
       return;
     }
     case AS_FORMAT: {
       SrcLoc mloc, nloc;
       i64 mv, nv;
       advance(p); /* '(' */
       if (p->cur.kind != TOK_IDENT) {
         perr(p, "attribute 'format' expects (archetype, m, n)");
       }
       advance(p);
       expect_punct(p, ',', "',' after format archetype");
       mloc = tok_loc(p, &p->cur);
       mv = eval_const_int(p, mloc);
       expect_punct(p, ',', "',' after format string-index");
       nloc = tok_loc(p, &p->cur);
       nv = eval_const_int(p, nloc);
       if (mv < 0 || mv > 0xFFFF || nv < 0 || nv > 0xFFFF) {
         perr(p, "attribute 'format' indices out of range");
       }
       a->v.format.fmt_idx = (u16)mv;
       a->v.format.first = (u16)nv;
       a->nargs = 3;
       expect_punct(p, ')', "')' after format arguments");
       return;
     }
     case AS_OPAQUE:
     default: {
       skip_balanced_parens(p);
       return;
     }
   }
 }
 
 Attr* parse_attribute_spec_list(Parser* p) {
   Attr* head = NULL;
   Attr* tail = NULL;
   while (starts_attr(p)) {
     SrcLoc kw_loc = tok_loc(p, &p->cur);
     advance(p); /* __attribute__ */
     expect_punct(p, '(', "'(' after __attribute__");
     expect_punct(p, '(', "'((' after __attribute__");
     for (;;) {
       Sym aname;
       AttrArgShape shape;
       Attr* a;
       const char* diag_name;
       size_t diag_len;
       const char* canon;
       size_t canon_len;
       while (accept_punct(p, ',')) { /* skip */
       }
       if (is_punct(&p->cur, ')')) break;
       if (p->cur.kind != TOK_IDENT) {
         perr(p, "expected attribute name");
       }
       aname = tok_ident(&p->cur);
       a = arena_new(p->pool->arena, Attr);
       if (!a) perr(p, "out of memory in parse_attribute_spec_list");
       memset(a, 0, sizeof *a);
       a->loc = tok_loc(p, &p->cur);
       a->name = aname;
       a->kind = (u16)classify_attr(p, aname, &shape);
       advance(p);
       {
         KitSlice aname_sl = kit_sym_str(p->pool->c, aname);
         diag_name = aname_sl.s;
         diag_len = aname_sl.len;
       }
       attr_canon_range(diag_name, diag_len, &canon, &canon_len);
       (void)canon;
       (void)canon_len;
       parse_attr_args(p, a, shape, diag_name ? diag_name : "<unknown>");
       if (tail)
         tail->next = a;
       else
         head = a;
       tail = a;
       if (!accept_punct(p, ',')) break;
     }
     expect_punct(p, ')', "')' after attribute list");
     expect_punct(p, ')', "'))' after attribute list");
     (void)kw_loc;
   }
   return head;
 }
 
 void parse_and_discard_attributes(Parser* p) {
   (void)parse_attribute_spec_list(p);
 }
 
 /* Append `add` to the end of `*head` (linked via Attr.next). */
 void attr_list_append(Attr** head, Attr* add) {
   if (!add) return;
   if (!*head) {
     *head = add;
     return;
   }
   Attr* tail = *head;
   while (tail->next) tail = tail->next;
   tail->next = add;
 }
 
 /* If `starts_attr`, parse and append to `*sink`. No-op otherwise. */
 void parse_attrs_into(Parser* p, Attr** sink) {
   if (starts_attr(p)) attr_list_append(sink, parse_attribute_spec_list(p));
 }
 
 #define PARSE_ATTR_ALIGNED_DEFAULT 16u
 
 static void attrs_to_record_opts(const Attr* a, TypeRecordOpts* opts) {
   for (; a; a = a->next) {
     if (a->kind == ATTR_PACKED) {
       opts->packed = 1;
     } else if (a->kind == ATTR_ALIGNED) {
       u32 v = (a->nargs == 0) ? PARSE_ATTR_ALIGNED_DEFAULT : (u32)a->v.i;
       if (v > opts->align_override) opts->align_override = (u16)v;
     }
   }
 }
 
 static void attrs_to_field(const Attr* a, Field* f) {
   for (; a; a = a->next) {
     if (a->kind == ATTR_PACKED) {
       f->packed = 1;
     } else if (a->kind == ATTR_ALIGNED) {
       u32 v = (a->nargs == 0) ? PARSE_ATTR_ALIGNED_DEFAULT : (u32)a->v.i;
       if (v > f->align_override) f->align_override = (u16)v;
     }
   }
 }
 
 u32 attrs_pick_aligned(const Attr* a) {
   u32 best = 0;
   for (; a; a = a->next) {
     if (a->kind == ATTR_ALIGNED) {
       u32 v = (a->nargs == 0) ? PARSE_ATTR_ALIGNED_DEFAULT : (u32)a->v.i;
       if (v > best) best = v;
     }
   }
   return best;
 }
 
 static int is_power_of_two_u32(u32 v) { return v != 0 && (v & (v - 1u)) == 0; }
 
 static void validate_atomic_operand(Parser* p, const Type* ty) {
   if (!ty) perr(p, "_Atomic requires an object type");
   if (ty->qual) perr(p, "_Atomic operand must not be qualified");
   if (ty->kind == TY_ARRAY || ty->kind == TY_FUNC || ty->kind == TY_VOID) {
     perr(p, "_Atomic operand must be an object type");
   }
 }
 
 void validate_decl_type_constraints(Parser* p, const DeclSpecs* specs,
                                     const Type* ty, int is_function,
                                     int is_member) {
   const Type* u = ty ? type_unqual(p->pool, ty) : NULL;
   if (!u) return;
   if (specs->quals & Q_RESTRICT) {
     perr(p, "restrict requires pointer type");
   }
   if ((ty->qual & Q_RESTRICT) && ty->kind != TY_PTR) {
     perr(p, "restrict requires pointer type");
   }
   if (is_member) {
     if (specs->storage != DS_AUTO || specs->storage_explicit) {
       perr(p, "storage-class specifier is invalid for struct member");
     }
     if (specs->flags & DF_INLINE)
       perr(p, "inline is invalid for struct member");
     if (specs->flags & DF_NORETURN)
       perr(p, "_Noreturn is invalid for struct member");
     if (specs->flags & DF_THREAD)
       perr(p, "_Thread_local is invalid for struct member");
   }
   if (u->kind == TY_VOID && !is_function && specs->storage != DS_TYPEDEF) {
     perr(p, "object may not have void type");
   }
   if ((specs->flags & DF_INLINE) && !is_function) {
     perr(p, "inline may only appear on a function declaration");
   }
   if ((specs->flags & DF_NORETURN) && !is_function) {
     perr(p, "_Noreturn may only appear on a function declaration");
   }
   if ((specs->flags & DF_THREAD) &&
       (is_function || specs->storage == DS_TYPEDEF)) {
     perr(p, "_Thread_local may only appear on object declarations");
   }
   if (specs->align) {
     u32 natural = 0;
     if (!is_power_of_two_u32(specs->align)) {
       perr(p, "_Alignas requires a power-of-two alignment");
     }
     if (is_function || specs->storage == DS_TYPEDEF) {
       perr(p, "_Alignas is invalid on this declaration");
     }
     if (u->kind == TY_VOID || u->kind == TY_FUNC) {
       perr(p, "_Alignas requires an object type");
     }
     natural = c_abi_alignof(p->abi, p->pool, ty);
     if (specs->align < natural) {
       perr(p, "_Alignas cannot weaken natural alignment");
     }
   }
 }
 
 /* ============================================================
  * resolve_type_specs
  * ============================================================ */
 
 const Type* resolve_type_specs(Parser* p, const TypeSpecAccum* a, SrcLoc loc) {
   if (!a->saw_explicit_type) return NULL;
   if (a->long_count > 2) {
     compiler_panic(p->c, loc, "too many long type specifiers");
   }
   if (a->saw_void) {
     if (a->saw_char || a->saw_int || a->saw_short || a->long_count ||
         a->saw_signed || a->saw_unsigned || a->saw_bool || a->saw_float ||
         a->saw_double) {
       compiler_panic(p->c, loc, "conflicting type specifiers (void mixed)");
     }
     return type_void(p->pool);
   }
   if (a->saw_bool) {
     if (a->saw_char || a->saw_int || a->saw_short || a->long_count ||
         a->saw_signed || a->saw_unsigned || a->saw_float || a->saw_double) {
       compiler_panic(p->c, loc, "conflicting type specifiers (_Bool mixed)");
     }
     return type_prim(p->pool, TY_BOOL);
   }
   if (a->saw_char) {
     if (a->saw_int || a->saw_short || a->long_count || a->saw_float ||
         a->saw_double) {
       compiler_panic(p->c, loc, "conflicting type specifiers (char mixed)");
     }
     if (a->saw_unsigned) return type_prim(p->pool, TY_UCHAR);
     if (a->saw_signed) return type_prim(p->pool, TY_SCHAR);
     return type_prim(p->pool, TY_CHAR);
   }
   if (a->saw_float) {
     if (a->saw_int || a->saw_short || a->long_count || a->saw_signed ||
         a->saw_unsigned || a->saw_double) {
       compiler_panic(p->c, loc, "conflicting type specifiers (float mixed)");
     }
     return type_prim(p->pool, TY_FLOAT);
   }
   if (a->saw_double) {
     if (a->saw_int || a->saw_short || a->saw_signed || a->saw_unsigned ||
         a->long_count > 1) {
       compiler_panic(p->c, loc, "conflicting type specifiers (double mixed)");
     }
     return type_prim(p->pool, a->long_count ? TY_LDOUBLE : TY_DOUBLE);
   }
   if (a->saw_short) {
     if (a->long_count) {
       compiler_panic(p->c, loc, "conflicting type specifiers (short long)");
     }
     return type_prim(p->pool, a->saw_unsigned ? TY_USHORT : TY_SHORT);
   }
   if (a->saw_int128) {
     if (!target_has_int128(p)) {
       perr(p, "__int128 is not supported on the target architecture");
     }
     return type_prim(p->pool, a->saw_unsigned ? TY_UINT128 : TY_INT128);
   }
   if (a->long_count == 2) {
     return type_prim(p->pool, a->saw_unsigned ? TY_ULLONG : TY_LLONG);
   }
   if (a->long_count == 1) {
     return type_prim(p->pool, a->saw_unsigned ? TY_ULONG : TY_LONG);
   }
   if (a->saw_unsigned) return type_prim(p->pool, TY_UINT);
   if (a->saw_signed || a->saw_int) return type_prim(p->pool, TY_INT);
   return type_prim(p->pool, TY_INT);
 }
 
 /* ============================================================
  * parse_decl_specs
  * ============================================================ */
 
 static int is_typeof_spelling(const Parser* p, const Tok* t) {
   Sym s;
   if (!p || !t || t->kind != TOK_IDENT) return 0;
   s = tok_ident(t);
   return s == p->sym_typeof_alias || s == p->sym_typeof_alias2;
 }
 
 static const Type* parse_typeof_specifier(Parser* p) {
   const Type* ty;
   advance(p); /* __typeof / __typeof__ */
   expect_punct(p, '(', "'(' after __typeof");
   if (starts_type_name(p, &p->cur)) {
     ty = parse_type_name(p);
   } else {
     /* Preserve the frontend Type without emitting operand side effects. This
      * retains qualified, array, and function types instead of applying the
      * usual value conversions. */
     c_const_guard_not_eval_push(p);
     c_cg_codegen_suppress_push(p);
     parse_expr(p);
     ty = c_cg_top_type(p);
     c_cg_drop(p);
     c_cg_codegen_suppress_pop(p);
     c_const_guard_not_eval_pop(p);
   }
   expect_punct(p, ')', "')' after __typeof operand");
   return ty;
 }
 
 int parse_decl_specs(Parser* p, DeclSpecs* out) {
   TypeSpecAccum acc;
   SrcLoc loc;
   int seen = 0;
   int storage_seen = 0;
   const Type* tagged_ty = NULL;
   memset(&acc, 0, sizeof acc);
   out->type = NULL;
   out->storage = DS_AUTO;
   out->flags = DF_NONE;
   out->quals = 0;
   out->storage_explicit = 0;
   out->pad = 0;
   out->align = 0;
   out->vla_byte_slot = FRAME_SLOT_NONE;
   out->vla_bounds = NULL;
   out->attrs = NULL;
   loc = tok_loc(p, &p->cur);
   for (;;) {
     Tok t = p->cur;
     /* Classify the token's keyword identity exactly once per iteration; the
      * decl-spec dispatch below compares against this instead of re-deciding
      * keyword-ness per candidate (was ~26 is_kw probes/token). */
     CKw tkw = classify_kw(p, &t);
     if (starts_attr(p)) {
       Attr* a = parse_attribute_spec_list(p);
       if (a) {
         Attr* tail = a;
         while (tail->next) tail = tail->next;
         tail->next = out->attrs;
         out->attrs = a;
       }
       seen = 1;
       continue;
     }
     if (is_typeof_spelling(p, &t)) {
       if (tagged_ty || acc.saw_explicit_type) {
         perr(p, "conflicting type specifiers (__typeof mixed)");
       }
       tagged_ty = parse_typeof_specifier(p);
       acc.saw_explicit_type = 1;
       seen = 1;
       continue;
     }
     if (tkw == KW_STRUCT || tkw == KW_UNION) {
       TypeKind kind = tkw == KW_STRUCT ? TY_STRUCT : TY_UNION;
       Attr* anon_attrs = NULL;
       if (tagged_ty || acc.saw_explicit_type) {
         perr(p, "conflicting type specifiers (struct/union mixed)");
       }
       advance(p);
       tagged_ty = parse_struct_or_union(p, kind, &anon_attrs);
       attr_list_append(&out->attrs, anon_attrs);
       acc.saw_explicit_type = 1;
       seen = 1;
       continue;
     }
     if (tkw == KW_ENUM) {
       Attr* anon_attrs = NULL;
       if (tagged_ty || acc.saw_explicit_type) {
         perr(p, "conflicting type specifiers (enum mixed)");
       }
       advance(p);
       tagged_ty = parse_enum(p, &anon_attrs);
       attr_list_append(&out->attrs, anon_attrs);
       acc.saw_explicit_type = 1;
       seen = 1;
       continue;
     }
     if (tkw == KW_VOID) {
       acc.saw_void = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_CHAR) {
       acc.saw_char = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_INT) {
       acc.saw_int = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_SHORT) {
       acc.saw_short = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_LONG) {
       acc.long_count++;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_SIGNED) {
       acc.saw_signed = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_UNSIGNED) {
       acc.saw_unsigned = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_BOOL) {
       acc.saw_bool = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_FLOAT || tkw == KW_FLOAT16) {
       reject_general_regs_only_fp(p, "floating-point types");
       /* _Float16 is intentionally aliased to 32-bit float (a deliberate
        * approximation; see test/parse/cases/float16_01_decl, which asserts
        * sizeof(_Float16) == sizeof(float)). Real 16-bit semantics would be a
        * separate feature. */
       acc.saw_float = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_DOUBLE) {
       reject_general_regs_only_fp(p, "floating-point types");
       acc.saw_double = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (t.kind == TOK_IDENT && tok_ident(&t) == p->sym_int128) {
       acc.saw_int128 = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (t.kind == TOK_IDENT && tok_ident(&t) == p->sym_int128_t) {
       acc.saw_int128 = 1;
       acc.saw_signed = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (t.kind == TOK_IDENT && tok_ident(&t) == p->sym_uint128_t) {
       acc.saw_int128 = 1;
       acc.saw_unsigned = 1;
       acc.saw_explicit_type = 1;
       advance(p);
       seen = 1;
     } else if (tkw == KW_STATIC) {
       if (storage_seen) perr(p, "multiple storage-class specifiers");
       storage_seen = 1;
       out->storage_explicit = 1;
       out->storage = DS_STATIC;
       advance(p);
       seen = 1;
     } else if (tkw == KW_EXTERN) {
       if (storage_seen) perr(p, "multiple storage-class specifiers");
       storage_seen = 1;
       out->storage_explicit = 1;
       out->storage = DS_EXTERN;
       advance(p);
       seen = 1;
     } else if (tkw == KW_CONST) {
       out->quals |= Q_CONST;
       advance(p);
       seen = 1;
     } else if (tkw == KW_VOLATILE) {
       out->quals |= Q_VOLATILE;
       advance(p);
       seen = 1;
     } else if (tkw == KW_RESTRICT) {
       out->quals |= Q_RESTRICT;
       advance(p);
       seen = 1;
     } else if (tkw == KW_ATOMIC) {
       Tok n = peek1(p);
       if (is_punct(&n, '(')) {
         const Type* inner;
         if (tagged_ty || acc.saw_explicit_type) {
           perr(p, "conflicting type specifiers (_Atomic(T) mixed)");
         }
         advance(p); /* `_Atomic` */
         advance(p); /* `(` */
         inner = parse_type_name(p);
         expect_punct(p, ')', "')' after _Atomic type");
         validate_atomic_operand(p, inner);
         tagged_ty = type_qualified(p->pool, inner, Q_ATOMIC);
         acc.saw_explicit_type = 1;
         seen = 1;
         continue;
       }
       out->quals |= Q_ATOMIC;
       advance(p);
       seen = 1;
     } else if (tkw == KW_TYPEDEF) {
       if (storage_seen) perr(p, "multiple storage-class specifiers");
       storage_seen = 1;
       out->storage_explicit = 1;
       out->storage = DS_TYPEDEF;
       advance(p);
       seen = 1;
     } else if (tkw == KW_ALIGNAS) {
       u32 a = 0;
       advance(p); /* `_Alignas` */
       expect_punct(p, '(', "'(' after _Alignas");
       if (starts_type_name(p, &p->cur)) {
         const Type* tn = parse_type_name(p);
         a = c_abi_alignof(p->abi, p->pool, tn);
       } else {
         i64 v = eval_const_int(p, tok_loc(p, &p->cur));
         if (v < 0) perr(p, "_Alignas requires a non-negative alignment");
         a = (u32)v;
       }
       if (a != 0 && !is_power_of_two_u32(a)) {
         perr(p, "_Alignas requires a power-of-two alignment");
       }
       expect_punct(p, ')', "')' after _Alignas argument");
       if (a > out->align) out->align = a;
       seen = 1;
     } else if (tkw == KW_INLINE) {
       out->flags |= DF_INLINE;
       advance(p);
       seen = 1;
     } else if (tkw == KW_THREAD_LOCAL) {
       out->flags |= DF_THREAD;
       advance(p);
       seen = 1;
     } else if (tkw == KW_NORETURN) {
       out->flags |= DF_NORETURN;
       advance(p);
       seen = 1;
     } else if (tkw == KW_REGISTER) {
       if (storage_seen) perr(p, "multiple storage-class specifiers");
       storage_seen = 1;
       out->storage_explicit = 1;
       out->storage = DS_REGISTER;
       advance(p);
       seen = 1;
     } else if (tkw == KW_AUTO) {
       if (storage_seen) perr(p, "multiple storage-class specifiers");
       storage_seen = 1;
       out->storage_explicit = 1;
       out->storage = DS_AUTO;
       advance(p);
       seen = 1;
     } else if (!acc.saw_explicit_type && !tagged_ty && t.kind == TOK_IDENT &&
                tkw == KW_NONE) {
       /* tkw == KW_NONE here is exactly ident_kw_inline(t)==KW_NONE: this is the
        * terminal else-if, so every keyword/alias branch above already failed.
        */
       if (tok_ident(&t) == p->sym_b_va_list) {
         if (!p->type_b_va_list)
           p->type_b_va_list = c_abi_va_list_type(p->abi, p->pool);
         tagged_ty = p->type_b_va_list;
         acc.saw_explicit_type = 1;
         advance(p);
         seen = 1;
         continue;
       }
       SymEntry* e = scope_lookup(p, tok_ident(&t));
       if (e && e->kind == SEK_TYPEDEF) {
         tagged_ty = e->type;
         if (e->vla_byte_slot != FRAME_SLOT_NONE) {
           out->vla_byte_slot = e->vla_byte_slot;
           out->vla_bounds = e->vla_bounds;
         }
         acc.saw_explicit_type = 1;
         advance(p);
         seen = 1;
         continue;
       }
       break;
     } else {
       break;
     }
   }
   if (seen) {
     if (tagged_ty) {
       out->type = tagged_ty;
     } else {
       out->type = resolve_type_specs(p, &acc, loc);
       if (!out->type) {
         out->type = ty_int(p);
       }
     }
     out->type = attrs_apply_type_mode(p, out->type, out->attrs);
     if (out->type && out->quals) {
       out->type = type_qualified(p->pool, out->type,
                                  (u16)(out->type->qual | out->quals));
     }
   }
   return seen;
 }
 
 /* ============================================================
  * struct / union / enum
  * ============================================================ */
 
 int find_field(KitCompiler* abi, Pool* pool, const Type* rec, Sym name,
                const Type** out_type, u32* out_offset,
                const Field** out_field) {
   if (!rec || (rec->kind != TY_STRUCT && rec->kind != TY_UNION)) return 0;
   const ABIRecordLayout* L = c_abi_record_layout(abi, pool, rec);
   if (!L) return 0;
   for (u16 i = 0; i < rec->rec.nfields; ++i) {
     const Field* f = &rec->rec.fields[i];
     if (f->name == name && name != 0) {
       *out_type = f->type;
       *out_offset = L->fields[i].offset;
       *out_field = f;
       return 1;
     }
     if ((f->flags & FIELD_ANON) &&
         (f->type->kind == TY_STRUCT || f->type->kind == TY_UNION)) {
       const Type* inner_ty = NULL;
       u32 inner_off = 0;
       const Field* inner_f = NULL;
       if (find_field(abi, pool, f->type, name, &inner_ty, &inner_off,
                      &inner_f)) {
         *out_type = inner_ty;
         *out_offset = L->fields[i].offset + inner_off;
         *out_field = inner_f;
         return 1;
       }
     }
   }
   return 0;
 }
 
 typedef struct MemberNameSeen {
   Sym name;
   struct MemberNameSeen* next;
 } MemberNameSeen;
 
 static int member_name_seen(MemberNameSeen* names, Sym name) {
   for (; names; names = names->next) {
     if (names->name == name) return 1;
   }
   return 0;
 }
 
 static void member_name_add(Parser* p, MemberNameSeen** names, Sym name) {
   MemberNameSeen* n;
   if (!name) return;
   n = arena_new(p->pool->arena, MemberNameSeen);
   if (!n) perr(p, "out of memory tracking struct members");
   n->name = name;
   n->next = *names;
   *names = n;
 }
 
 static void validate_and_add_field(Parser* p, TypeRecordBuilder* b,
                                    const DeclSpecs* specs, Field* f,
                                    MemberNameSeen** names, u32* field_count,
                                    int* saw_flexible) {
   int is_flexible =
       f->type && f->type->kind == TY_ARRAY && f->type->arr.incomplete;
   validate_decl_type_constraints(p, specs, f->type, /*is_function=*/0,
                                  /*is_member=*/1);
   if ((f->flags & FIELD_BITFIELD) && specs->align) {
     perr(p, "_Alignas is invalid on bit-field");
   }
   if (f->name && member_name_seen(*names, f->name)) {
     perr(p, "duplicate member name");
   }
   if (*saw_flexible) perr(p, "flexible array member must be last");
   if (is_flexible) {
     if (*field_count == 0)
       perr(p, "flexible array member cannot be only member");
     f->flags |= FIELD_FLEXIBLE_ARRAY;
     *saw_flexible = 1;
   }
   member_name_add(p, names, f->name);
   type_record_field(b, *f);
   ++*field_count;
 }
 
 static void parse_member_decls(Parser* p, TypeRecordBuilder* b) {
   MemberNameSeen* names = NULL;
   u32 field_count = 0;
   int saw_flexible = 0;
   while (!is_punct(&p->cur, '}') && p->cur.kind != TOK_EOF) {
     DeclSpecs specs;
     if (!parse_decl_specs(p, &specs)) {
       perr(p, "expected member declaration");
     }
     if (is_punct(&p->cur, ';')) {
       if (specs.type &&
           (specs.type->kind == TY_STRUCT || specs.type->kind == TY_UNION)) {
         Field f;
         memset(&f, 0, sizeof f);
         f.name = 0;
         f.type = specs.type;
         f.flags = FIELD_ANON;
         validate_and_add_field(p, b, &specs, &f, &names, &field_count,
                                &saw_flexible);
         advance(p);
         continue;
       }
       perr(p, "declaration without declarator must be anonymous aggregate");
     }
     for (;;) {
       Sym mname = 0;
       SrcLoc mloc = tok_loc(p, &p->cur);
       const Type* mty;
       Field f;
       memset(&f, 0, sizeof f);
       if (is_punct(&p->cur, ':')) {
         advance(p);
         if (!type_is_int(specs.type)) perr(p, "bit-field has non-integer type");
         i64 w = eval_const_int(p, mloc);
         if (w < 0) perr(p, "negative bit-field width");
         if (w > (i64)c_abi_sizeof(p->abi, p->pool, specs.type) * 8) {
           perr(p, "bit-field width exceeds its type width");
         }
         f.name = 0;
         f.type = specs.type;
         f.bitfield_width = (u16)w;
         f.flags = FIELD_BITFIELD;
         if (w == 0) f.flags |= FIELD_ZERO_WIDTH;
         attrs_to_field(specs.attrs, &f);
         if (specs.align > f.align_override) f.align_override = (u16)specs.align;
         validate_and_add_field(p, b, &specs, &f, &names, &field_count,
                                &saw_flexible);
         if (!accept_punct(p, ',')) break;
         continue;
       }
       Attr* mattrs = NULL;
       mty = parse_declarator_full_ex(p, specs.type, /*allow_abstract=*/0,
                                      &mname, &mloc, &mattrs);
       if (accept_punct(p, ':')) {
         if (!type_is_int(mty)) perr(p, "bit-field has non-integer type");
         i64 w = eval_const_int(p, mloc);
         if (w < 0) perr(p, "negative bit-field width");
         if (w == 0 && mname != 0)
           perr(p, "zero-width bit-field must be unnamed");
         if (w > (i64)c_abi_sizeof(p->abi, p->pool, mty) * 8) {
           perr(p, "bit-field width exceeds its type width");
         }
         f.name = mname;
         f.type = mty;
         f.bitfield_width = (u16)w;
         f.flags = FIELD_BITFIELD;
         if (w == 0) f.flags |= FIELD_ZERO_WIDTH;
       } else {
         f.name = mname;
         f.type = mty;
         f.flags = FIELD_NONE;
       }
       attrs_to_field(specs.attrs, &f);
       attrs_to_field(mattrs, &f);
       {
         Attr* trailing = NULL;
         parse_attrs_into(p, &trailing);
         attrs_to_field(trailing, &f);
       }
       if (specs.align > f.align_override) f.align_override = (u16)specs.align;
       validate_and_add_field(p, b, &specs, &f, &names, &field_count,
                              &saw_flexible);
       if (!accept_punct(p, ',')) break;
     }
     expect_punct(p, ';', "';' after struct member declaration");
   }
 }
 
 const Type* parse_struct_or_union(Parser* p, TypeKind kind,
                                   Attr** anon_attrs_out) {
   Sym tag_name = 0;
   SrcLoc tag_loc;
   TagDeclKind tdk = (kind == TY_STRUCT) ? TAG_STRUCT : TAG_UNION;
   Attr* rec_attrs = NULL;
   parse_attrs_into(p, &rec_attrs);
   tag_loc = tok_loc(p, &p->cur);
   if (p->cur.kind == TOK_IDENT &&
       ident_kw_inline(p, tok_ident(&p->cur)) == KW_NONE) {
     tag_name = tok_ident(&p->cur);
     advance(p);
   }
   int has_body = is_punct(&p->cur, '{');
   if (!has_body && tag_name == 0) {
     perr(p, "expected tag name or '{' after struct/union");
   }
   if (!has_body) {
     TagEntry* e = tag_lookup(p, tag_name);
     if (e) {
       if (e->kind != tdk) {
         perr(p, "use of tag with wrong kind (struct vs union)");
       }
       attr_list_append(&e->attrs, rec_attrs);
       return e->type;
     }
     {
       TagId tid = type_tag_new(p->pool, tdk, tag_name, tag_loc);
       Type* t = type_record_forward(p->pool, kind, tid, tag_name);
       TagEntry* te = tag_define(p, tag_name, tdk, t, /*complete=*/0);
       attr_list_append(&te->attrs, rec_attrs);
       return t;
     }
   }
   Type* target = NULL;
   TagEntry* existing = tag_name ? tag_lookup_local(p, tag_name) : NULL;
   TagEntry* te = NULL;
   if (existing) {
     if (existing->kind != tdk) {
       perr(p, "tag redeclared with wrong kind");
     }
     if (existing->complete) {
       perr(p, "redefinition of tag");
     }
     target = existing->type;
     te = existing;
   } else {
     TagId tid = type_tag_new(p->pool, tdk, tag_name, tag_loc);
     target = type_record_forward(p->pool, kind, tid, tag_name);
     if (tag_name) {
       te = tag_define(p, tag_name, tdk, target, /*complete=*/0);
     }
   }
   if (te) {
     attr_list_append(&te->attrs, rec_attrs);
   } else if (anon_attrs_out) {
     attr_list_append(anon_attrs_out, rec_attrs);
   }
   expect_punct(p, '{', "'{' to start aggregate body");
   TypeRecordOpts begin_opts;
   memset(&begin_opts, 0, sizeof begin_opts);
   {
     u32 pack_align = pp_pack_alignment(p->pp);
     if (pack_align > 65535u) pack_align = 65535u;
     begin_opts.max_align = (u16)pack_align;
   }
   attrs_to_record_opts(rec_attrs, &begin_opts);
   TypeRecordBuilder* b = type_record_begin_ex(p->pool, kind, target->rec.tag_id,
                                               tag_name, begin_opts);
   parse_member_decls(p, b);
   expect_punct(p, '}', "'}' after aggregate body");
   TypeRecordOpts trailing_opts;
   memset(&trailing_opts, 0, sizeof trailing_opts);
   {
     Attr* trailing_attrs = NULL;
     parse_attrs_into(p, &trailing_attrs);
     attrs_to_record_opts(trailing_attrs, &trailing_opts);
     if (te) {
       attr_list_append(&te->attrs, trailing_attrs);
     } else if (anon_attrs_out) {
       attr_list_append(anon_attrs_out, trailing_attrs);
     }
   }
   {
     const Type* fresh = type_record_end(p->pool, b);
     target->rec.packed = fresh->rec.packed;
     target->rec.max_align = fresh->rec.max_align;
     target->rec.align_override = fresh->rec.align_override;
     type_record_install(target, (Field*)fresh->rec.fields, fresh->rec.nfields);
   }
   if (trailing_opts.packed) target->rec.packed = 1;
   if (trailing_opts.align_override > target->rec.align_override)
     target->rec.align_override = trailing_opts.align_override;
   if (te) te->complete = 1;
   return target;
 }
 
 const Type* parse_enum(Parser* p, Attr** anon_attrs_out) {
   Sym tag_name = 0;
   SrcLoc tag_loc;
   Attr* rec_attrs = NULL;
   parse_attrs_into(p, &rec_attrs);
   tag_loc = tok_loc(p, &p->cur);
   if (p->cur.kind == TOK_IDENT &&
       ident_kw_inline(p, tok_ident(&p->cur)) == KW_NONE) {
     tag_name = tok_ident(&p->cur);
     advance(p);
   }
   /* C23 §6.7.2.2: an optional fixed underlying type — `enum [tag] : T` —
    * may follow the tag (or `enum`), in both the defining and the
    * forward-declaring forms. T is an integer type-specifier list; we reuse
    * the type-name parser and adopt T as the enum's representation type. */
   const Type* underlying = ty_int(p);
   int has_fixed_type = 0;
   if (accept_punct(p, ':')) {
     underlying = parse_type_name(p);
     has_fixed_type = 1;
   }
   int has_body = is_punct(&p->cur, '{');
   if (!has_body && tag_name == 0) {
     perr(p, "expected tag name or '{' after enum");
   }
   if (!has_body) {
     TagEntry* e = tag_lookup(p, tag_name);
     if (e && e->kind == TAG_ENUM) {
       attr_list_append(&e->attrs, rec_attrs);
       return e->type;
     }
     if (e) {
       perr(p, "tag redeclared with wrong kind");
     }
     if (!has_fixed_type) {
       perr(p, "enum tag declared without definition");
     }
     /* C23 `enum E : T;` with no enumerators is a forward declaration carrying a
      * fixed underlying type. Record an *incomplete* tag (so the type knows T)
      * that a later `enum E : T { ... }` can complete; a redefinition is only
      * diagnosed once an enumerator body actually arrives. */
     {
       TagId ftid = type_tag_new(p->pool, TAG_ENUM, tag_name, tag_loc);
       const Type* fet = type_enum(p->pool, ftid, tag_name, underlying);
       TagEntry* te =
           tag_define(p, tag_name, TAG_ENUM, (Type*)fet, /*complete=*/0);
       attr_list_append(&te->attrs, rec_attrs);
       return fet;
     }
   }
   TagId tid = type_tag_new(p->pool, TAG_ENUM, tag_name, tag_loc);
   const Type* et = type_enum(p->pool, tid, tag_name, underlying);
   expect_punct(p, '{', "'{'");
   i64 next_val = 0;
   /* Collect enumerators so the enum Type can carry them into CG/debug info
    * (DW_TAG_enumerator). Geometric growth from the arena keeps it allocation-
    * light; the arena never frees, but enum bodies are small. */
   EnumConst* consts = NULL;
   u32 nconsts = 0, consts_cap = 0;
   for (;;) {
     Sym name;
     SrcLoc nloc = tok_loc(p, &p->cur);
     SymEntry* e;
     if (p->cur.kind != TOK_IDENT ||
         ident_kw_inline(p, tok_ident(&p->cur)) != KW_NONE) {
       perr(p, "expected enumerator name");
     }
     name = tok_ident(&p->cur);
     advance(p);
     i64 val = next_val;
     if (accept_punct(p, '=')) {
       val = eval_const_int(p, nloc);
     }
     if (scope_lookup_current(p, name)) {
       perr(p, "redefinition of enumerator");
     }
     e = scope_define(p, name, SEK_ENUM_CST, et);
     e->v.enum_value = val;
     next_val = val + 1;
     if (nconsts == consts_cap) {
       u32 newcap = consts_cap ? consts_cap * 2u : 8u;
       EnumConst* grown = arena_array(p->pool->arena, EnumConst, newcap);
       if (grown && consts) memcpy(grown, consts, nconsts * sizeof(EnumConst));
       consts = grown;
       consts_cap = grown ? newcap : 0;
     }
     if (consts && nconsts < UINT16_MAX) {
       consts[nconsts].name = name;
       consts[nconsts].value = val;
       nconsts++;
     }
     if (!accept_punct(p, ',')) break;
     if (is_punct(&p->cur, '}')) break;
   }
   expect_punct(p, '}', "'}' after enumerator list");
   ((Type*)et)->enm.consts = consts;
   ((Type*)et)->enm.nconsts = (u16)nconsts;
   parse_attrs_into(p, &rec_attrs);
   if (tag_name) {
     TagEntry* existing = tag_lookup_local(p, tag_name);
     if (existing) {
       if (existing->kind != TAG_ENUM) {
         perr(p, "tag redeclared with wrong kind");
       }
       if (existing->complete) {
         perr(p, "redefinition of enum tag");
       }
       existing->complete = 1;
       attr_list_append(&existing->attrs, rec_attrs);
     } else {
       TagEntry* te = tag_define(p, tag_name, TAG_ENUM, (Type*)et,
                                 /*complete=*/1);
       attr_list_append(&te->attrs, rec_attrs);
     }
   } else if (anon_attrs_out) {
     attr_list_append(anon_attrs_out, rec_attrs);
   }
   return et;
 }
 
 /* ============================================================
  * starts_type_name, parse_pointer_layer, parse_type_name
  * ============================================================ */
 
 int starts_type_name(const Parser* p, const Tok* t) {
   if (t->kind != TOK_IDENT) return 0;
   if (is_typeof_spelling(p, t)) return 1;
   CKw k = ident_kw_inline(p, tok_ident(t));
   switch (k) {
     case KW_VOID:
     case KW_CHAR:
     case KW_SHORT:
     case KW_INT:
     case KW_LONG:
     case KW_FLOAT:
     case KW_FLOAT16:
     case KW_DOUBLE:
     case KW_SIGNED:
     case KW_UNSIGNED:
     case KW_BOOL:
     case KW_STRUCT:
     case KW_UNION:
     case KW_ENUM:
     case KW_CONST:
     case KW_VOLATILE:
     case KW_RESTRICT:
     case KW_ATOMIC:
     case KW_STATIC:
     case KW_EXTERN:
     case KW_INLINE:
     case KW_NORETURN:
     case KW_REGISTER:
     case KW_AUTO:
     case KW_TYPEDEF:
     case KW_ALIGNAS:
     case KW_THREAD_LOCAL:
       return 1;
     case KW_NONE: {
       if (tok_ident(t) == p->sym_b_va_list) return 1;
       if (tok_ident(t) == p->sym_int128 || tok_ident(t) == p->sym_int128_t ||
           tok_ident(t) == p->sym_uint128_t)
         return 1;
       SymEntry* e = scope_lookup((Parser*)p, tok_ident(t));
       return e && e->kind == SEK_TYPEDEF;
     }
     default:
       return 0;
   }
 }
 
 const Type* parse_pointer_layer(Parser* p, const Type* base) {
   while (accept_punct(p, '*')) {
     u16 q = 0;
     base = type_ptr(p->pool, base);
     for (;;) {
       if (accept_kw(p, KW_CONST)) {
         q |= Q_CONST;
         continue;
       }
       if (accept_kw(p, KW_VOLATILE)) {
         q |= Q_VOLATILE;
         continue;
       }
       if (accept_kw(p, KW_RESTRICT)) {
         q |= Q_RESTRICT;
         continue;
       }
       if (accept_kw(p, KW_ATOMIC)) {
         q |= Q_ATOMIC;
         continue;
       }
       if (starts_attr(p)) {
         parse_and_discard_attributes(p);
         continue;
       }
       break;
     }
     if (q) base = type_qualified(p->pool, base, q);
   }
   return base;
 }
 
 const Type* parse_type_name(Parser* p) {
   DeclSpecs specs;
   Sym dummy_name = 0;
   SrcLoc dummy_loc = {0, 0, 0};
   if (!parse_decl_specs(p, &specs)) {
     perr(p, "expected type-name");
   }
   return parse_declarator_full(p, specs.type, /*allow_abstract=*/1, &dummy_name,
                                &dummy_loc);
 }
 
 /* ============================================================
  * Declarator suffix helpers
  * (DeclSuffix / DSuffKind defined in parse_priv.h)
  * ============================================================ */
 
 static void param_vla_record_bound(Parser* p, Tok* toks, u32 ntoks,
                                    int has_expr) {
   ParamVLABoundExpr* b;
   if (p->param_vla_bound_len >=
       sizeof p->param_vla_bounds / sizeof p->param_vla_bounds[0]) {
     perr(p, "too many VLA dimensions per parameter");
   }
   b = &p->param_vla_bounds[p->param_vla_bound_len++];
   b->toks = toks;
   b->ntoks = ntoks;
   b->has_expr = (u8)(has_expr ? 1 : 0);
 }
 
 static void parse_param_array_bound(Parser* p, DeclSuffix* out) {
   Tok* toks = NULL;
   u32 ntoks = 0;
   u32 cap = 0;
   int depth = 1;
   int has_expr = 0;
 
   out->incomplete = 1;
   if (accept_punct(p, ']')) {
     param_vla_record_bound(p, NULL, 0, 0);
     return;
   }
   while (depth > 0) {
     Tok t = p->cur;
     if (t.kind == TOK_EOF) {
       perr(p, "unexpected EOF in parameter array bound");
     }
     if (is_punct(&t, '[')) {
       ++depth;
     } else if (is_punct(&t, ']')) {
       --depth;
       if (depth == 0) break;
     }
     if (ntoks == cap) {
       u32 nc = cap ? cap * 2u : 4u;
       Tok* nb = arena_array(p->pool->arena, Tok, nc);
       if (toks && ntoks) memcpy(nb, toks, sizeof(Tok) * ntoks);
       toks = nb;
       cap = nc;
     }
     toks[ntoks++] = t;
     has_expr = 1;
     advance(p);
   }
   if (ntoks == 1 && toks[0].kind == TOK_PUNCT && tok_punct(&toks[0]) == '*') {
     has_expr = 0;
   }
   if (ntoks == 1 && toks[0].kind == TOK_NUM) {
     i64 count = parse_int_literal(p, &toks[0]);
     if (count <= 0 || (u64)count > UINT32_MAX) {
       perr(p, "array bound must be positive");
     }
     out->count = (u32)count;
     out->incomplete = 0;
     out->vla = 0;
     expect_punct(p, ']', "']' after array size");
     return;
   }
   param_vla_record_bound(p, toks, ntoks, has_expr);
   expect_punct(p, ']', "']' after array size");
 }
 
 int parse_decl_suffix(Parser* p, DeclSuffix* out) {
   if (accept_punct(p, '[')) {
     out->kind = DS_ARRAY;
     out->count = 0;
     out->incomplete = 0;
     out->vla = 0;
     for (;;) {
       if (accept_kw(p, KW_STATIC) || accept_kw(p, KW_CONST) ||
           accept_kw(p, KW_VOLATILE) || accept_kw(p, KW_RESTRICT) ||
           accept_kw(p, KW_ATOMIC)) {
         continue;
       }
       break;
     }
     if (p->in_param_decl) {
       parse_param_array_bound(p, out);
       return 1;
     }
     if (accept_punct(p, ']')) {
       out->incomplete = 1;
       return 1;
     }
     {
       Tok t = p->cur;
       /* A VLA is a block-scope-only feature (§6.7.6.2¶4): at file scope every
        * declared array bound must be an integer constant expression. Route all
        * file-scope bounds through eval_const_int below, so a non-constant bound
        * becomes a clean "non-constant ... in constant expression" diagnostic
        * instead of entering the VLA codegen path — which assumes an active
        * function frame (c_cg_local/alloca/branch) and, with none at file scope,
        * silently miscompiles or hangs. */
       int is_const_start =
           p->cur_func_name == 0 || t.kind == TOK_NUM || t.kind == TOK_CHR;
       if (t.kind == TOK_FLT) {
         perr(p, "array bound requires integer type");
       }
       if (!is_const_start && t.kind == TOK_IDENT) {
         SymEntry* e = scope_lookup(p, tok_ident(&t));
         if (e && e->kind == SEK_ENUM_CST) is_const_start = 1;
         if (!is_const_start) {
           CKw k = ident_kw_inline(p, tok_ident(&t));
           if (k == KW_SIZEOF || k == KW_ALIGNOF) is_const_start = 1;
         }
       }
       if (is_const_start) {
         SrcLoc cloc = tok_loc(p, &p->cur);
         i64 v = eval_const_int(p, cloc);
         if (v < 0) perr(p, "negative array size");
         out->count = (u32)v;
       } else {
         FrameSlotDesc fsd;
         if (p->vla_pending_count_len >=
             sizeof p->vla_pending_count_slots /
                 sizeof p->vla_pending_count_slots[0]) {
           perr(p, "too many VLA dimensions per declarator");
         }
         out->vla = 1;
         memset(&fsd, 0, sizeof fsd);
         fsd.type = ty_size_t(p);
         fsd.size = c_abi_sizeof(p->abi, p->pool, fsd.type);
         fsd.align = c_abi_alignof(p->abi, p->pool, fsd.type);
         fsd.kind = FS_LOCAL;
         out->vla_count_slot = c_cg_local(p, &fsd);
         parse_assign_expr(p);
         to_rvalue(p);
         c_cg_push_local_typed(p, out->vla_count_slot, fsd.type);
         c_cg_swap(p);
         coerce_top_to_lvalue(p);
         c_cg_store_void(p);
         p->vla_pending = 1;
         ++p->vla_mark;
         p->vla_pending_count_slot = out->vla_count_slot;
         p->vla_pending_count_slots[p->vla_pending_count_len++] =
             out->vla_count_slot;
       }
     }
     expect_punct(p, ']', "']' after array size");
     return 1;
   }
   if (accept_punct(p, '(')) {
     out->kind = DS_FUNC;
     out->params = NULL;
     out->nparams = 0;
     out->variadic = 0;
     parse_param_list(p, &out->params, &out->nparams, &out->variadic);
     expect_punct(p, ')', "')' after parameter list");
     return 1;
   }
   return 0;
 }
 
 const Type* apply_decl_suffix(Parser* p, const Type* base,
                               const DeclSuffix* s) {
   if (s->kind == DS_ARRAY) {
     if (base && base->kind == TY_FUNC) {
       perr(p, "array of function type is invalid");
     }
     if (base && base->kind == TY_VOID) {
       perr(p, "array of void type is invalid");
     }
     /* C11 6.7.6.2p1: an array's element type must be complete. Completeness is
      * fixed where the array declarator is formed, so an incomplete record stays
      * an error here even if its tag is completed later (or never) -- this is
      * the constraint that rejects `struct N { struct N a[10]; }` while a
      * pointer element (`struct N *a[10]`) stays legal because a pointer is
      * complete. Element incompleteness is checked only for records: VLAs share
      * the array `incomplete` flag, so an incomplete-array element cannot be
      * told apart from a valid VLA element here and is intentionally not
      * diagnosed. */
     if (base && (base->kind == TY_STRUCT || base->kind == TY_UNION) &&
         base->rec.incomplete) {
       if (base->rec.tag) {
         perr(p, "array has incomplete element type '%s %.*s'",
              base->kind == TY_UNION ? "union" : "struct",
              KIT_SLICE_ARG(kit_sym_str(p->pool->c, base->rec.tag)));
       }
       perr(p, "array has incomplete element type");
     }
     return type_array(p->pool, base, s->count, s->incomplete || s->vla);
   }
   {
     const Type** ptypes = NULL;
     if (base && base->kind == TY_ARRAY) {
       perr(p, "function returning array is invalid");
     }
     if (base && base->kind == TY_FUNC) {
       perr(p, "function returning function is invalid");
     }
     if (s->nparams) {
       ptypes =
           (const Type**)arena_array(p->pool->arena, const Type*, s->nparams);
       for (u16 i = 0; i < s->nparams; ++i) ptypes[i] = s->params[i].type;
     }
     return type_func(p->pool, base, ptypes, s->nparams, (int)s->variadic);
   }
 }
 
 /* ============================================================
  * parse_declarator_full, parse_declarator_full_ex, parse_declarator
  * ============================================================ */
 
 const Type* parse_declarator_full(Parser* p, const Type* base,
                                   int allow_abstract, Sym* name_out,
                                   SrcLoc* loc_out) {
   return parse_declarator_full_ex(p, base, allow_abstract, name_out, loc_out,
                                   NULL);
 }
 
 const Type* parse_declarator_full_ex(Parser* p, const Type* base,
                                      int allow_abstract, Sym* name_out,
                                      SrcLoc* loc_out, Attr** attrs_out) {
   return parse_declarator_full_info(p, base, allow_abstract, name_out, loc_out,
                                     attrs_out, NULL);
 }
 
 const Type* parse_declarator_full_info(Parser* p, const Type* base,
                                        int allow_abstract, Sym* name_out,
                                        SrcLoc* loc_out, Attr** attrs_out,
                                        DeclaratorInfo* info_out) {
   Attr* local_attrs = NULL;
   Sym asm_label = 0;
   base = parse_pointer_layer(p, base);
 
   Sym name = 0;
   SrcLoc nloc = {0, 0, 0};
   u8 nptrs_inner = 0;
   u16 inner_quals[8];
   u8 nptrs_nested = 0;
   u16 nested_quals[8];
   int has_inner_parens = 0;
   DeclSuffix inner_suffs[8];
   int n_inner_suffs = 0;
 
   if (is_punct(&p->cur, '(')) {
     Tok n = peek1(p);
     int is_inner = 0;
     if (is_punct(&n, '*')) {
       is_inner = 1;
     } else if (n.kind == TOK_IDENT &&
                ident_kw_inline(p, tok_ident(&n)) == KW_NONE) {
       SymEntry* e = scope_lookup(p, tok_ident(&n));
       if (!(e && e->kind == SEK_TYPEDEF)) is_inner = 1;
     }
     if (is_inner) {
       has_inner_parens = 1;
       advance(p); /* '(' */
       while (accept_punct(p, '*')) {
         u16 q = 0;
         if (nptrs_inner >= 8) perr(p, "too many pointer levels");
         for (;;) {
           if (accept_kw(p, KW_CONST)) {
             q |= Q_CONST;
             continue;
           }
           if (accept_kw(p, KW_VOLATILE)) {
             q |= Q_VOLATILE;
             continue;
           }
           if (accept_kw(p, KW_RESTRICT)) {
             q |= Q_RESTRICT;
             continue;
           }
           if (accept_kw(p, KW_ATOMIC)) {
             q |= Q_ATOMIC;
             continue;
           }
           if (starts_attr(p) || starts_asm_label(p)) {
             parse_and_discard_attrs_or_asm(p);
             continue;
           }
           break;
         }
         inner_quals[nptrs_inner++] = q;
       }
       if (p->cur.kind == TOK_IDENT &&
           ident_kw_inline(p, tok_ident(&p->cur)) == KW_NONE) {
         name = tok_ident(&p->cur);
         nloc = tok_loc(p, &p->cur);
         advance(p);
       } else if (is_punct(&p->cur, '(')) {
         Tok nn = peek1(p);
         if (!is_punct(&nn, '*')) {
           if (!allow_abstract) perr(p, "expected declarator name");
           goto after_inner_name;
         }
         advance(p); /* nested '(' */
         while (accept_punct(p, '*')) {
           u16 q = 0;
           if (nptrs_nested >= 8) perr(p, "too many pointer levels");
           for (;;) {
             if (accept_kw(p, KW_CONST)) {
               q |= Q_CONST;
               continue;
             }
             if (accept_kw(p, KW_VOLATILE)) {
               q |= Q_VOLATILE;
               continue;
             }
             if (accept_kw(p, KW_RESTRICT)) {
               q |= Q_RESTRICT;
               continue;
             }
             if (accept_kw(p, KW_ATOMIC)) {
               q |= Q_ATOMIC;
               continue;
             }
             if (starts_attr(p) || starts_asm_label(p)) {
               parse_and_discard_attrs_or_asm(p);
               continue;
             }
             break;
           }
           nested_quals[nptrs_nested++] = q;
         }
         if (p->cur.kind == TOK_IDENT &&
             ident_kw_inline(p, tok_ident(&p->cur)) == KW_NONE) {
           name = tok_ident(&p->cur);
           nloc = tok_loc(p, &p->cur);
           advance(p);
         } else if (!allow_abstract) {
           perr(p, "expected declarator name");
         }
         parse_and_discard_attrs_or_asm(p);
         expect_punct(p, ')', "')' after nested declarator");
       } else if (!allow_abstract) {
         perr(p, "expected declarator name");
       }
     after_inner_name:
       parse_and_discard_attrs_or_asm(p);
       while (n_inner_suffs < 8) {
         if (!parse_decl_suffix(p, &inner_suffs[n_inner_suffs])) break;
         ++n_inner_suffs;
         parse_and_discard_attrs_or_asm(p);
       }
       expect_punct(p, ')', "')' after inner declarator");
     }
   }
 
   if (!has_inner_parens) {
     if (p->cur.kind == TOK_IDENT &&
         ident_kw_inline(p, tok_ident(&p->cur)) == KW_NONE) {
       name = tok_ident(&p->cur);
       nloc = tok_loc(p, &p->cur);
       advance(p);
     } else if (!allow_abstract) {
       perr(p, "expected declarator name");
     }
   }
 
   parse_attrs_and_asm_into(p, attrs_out, &local_attrs, &asm_label);
 
   DeclSuffix suffs[8];
   int nsuffs = 0;
   DeclSuffix* final_fn_suff = NULL;
   if (info_out) memset(info_out, 0, sizeof *info_out);
   while (nsuffs < 8) {
     if (!parse_decl_suffix(p, &suffs[nsuffs])) break;
     ++nsuffs;
     parse_attrs_and_asm_into(p, attrs_out, &local_attrs, &asm_label);
   }
   base = attrs_apply_type_mode(p, base, attrs_out ? *attrs_out : local_attrs);
   if (nsuffs == 8 && (is_punct(&p->cur, '[') || is_punct(&p->cur, '('))) {
     perr(p, "too many declarator suffixes (raise the cap if needed)");
   }
   if (n_inner_suffs > 0 && inner_suffs[0].kind == DS_FUNC) {
     final_fn_suff = &inner_suffs[0];
   } else if (n_inner_suffs == 0 && nptrs_inner == 0 && nsuffs > 0 &&
              suffs[0].kind == DS_FUNC) {
     final_fn_suff = &suffs[0];
   }
   for (int i = nsuffs - 1; i >= 0; --i) {
     base = apply_decl_suffix(p, base, &suffs[i]);
   }
 
   for (int i = (int)nptrs_inner - 1; i >= 0; --i) {
     base = type_ptr(p->pool, base);
     if (inner_quals[i]) {
       base = type_qualified(p->pool, base, inner_quals[i]);
     }
   }
 
   for (int i = n_inner_suffs - 1; i >= 0; --i) {
     base = apply_decl_suffix(p, base, &inner_suffs[i]);
   }
 
   for (int i = (int)nptrs_nested - 1; i >= 0; --i) {
     base = type_ptr(p->pool, base);
     if (nested_quals[i]) {
       base = type_qualified(p->pool, base, nested_quals[i]);
     }
   }
 
   if (info_out && base && base->kind == TY_FUNC && final_fn_suff) {
     info_out->fn_params = final_fn_suff->params;
     info_out->fn_nparams = final_fn_suff->nparams;
     info_out->fn_variadic = final_fn_suff->variadic;
   }
   if (info_out) info_out->asm_label = asm_label;
   if (name_out) *name_out = name;
   if (loc_out) *loc_out = nloc;
   return base;
 }
 
 const Type* parse_declarator(Parser* p, const Type* base, Sym* name_out,
                              SrcLoc* loc_out) {
   return parse_declarator_full(p, base, /*allow_abstract=*/0, name_out,
                                loc_out);
 }
 
 /* ============================================================
  * complete_incomplete_array
  * ============================================================ */
 
 const Type* complete_incomplete_array(Parser* p, const Type* ty) {
   const Type* elem;
   if (!ty || ty->kind != TY_ARRAY || !ty->arr.incomplete) return ty;
   elem = ty->arr.elem;
   if (p->cur.kind == TOK_STR &&
       string_literal_initializes_array(p, elem, &p->cur)) {
     Tok t = p->cur;
     size_t n = 0;
     u8* bytes = decode_string_literal(p, &t, &n);
     u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem);
     kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                            bytes, 0);
     return type_array(p->pool, elem, elem_size ? (u32)(n / elem_size) : 0,
                       /*incomplete=*/0);
   }
   if (is_punct(&p->cur, '{')) {
     u32 cnt;
     record_braced_block(p);
     cnt = count_recorded_top_level_items(p->replay, p->replay_len);
     if (cnt == 1 && p->replay_len >= 3 && p->replay[1].kind == TOK_STR &&
         string_literal_initializes_array(p, elem, &p->replay[1])) {
       Tok t = p->replay[1];
       size_t n = 0;
       u8* bytes = decode_string_literal(p, &t, &n);
       u32 elem_size = c_abi_sizeof(p->abi, p->pool, elem);
       kit_compiler_context(p->c)->heap->free(kit_compiler_context(p->c)->heap,
                                              bytes, 0);
       cnt = elem_size ? (u32)(n / elem_size) : 0;
     }
     replay_rewind(p);
     return type_array(p->pool, elem, cnt, /*incomplete=*/0);
   }
   perr(p, "initializer cannot complete incomplete array type");
 }