kit

expr.c (64036B)

---

 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "internal.h"
 
 /* Public CG API coverage goals for this frontend are tracked in
  * doc/toy-todo.md. Keep this file aligned with include/kit/cg.h rather than
  * private CG implementation details. */
 
 /* ============================================================
  * Parser (single-pass parse -> codegen)
  * ============================================================ */
 
 /* ============================================================
  * Expression parsing
  * ============================================================ */
 
 KitCgTypeId toy_parse_expr(ToyParser* p);
 KitCgMemAccess toy_mem_access(ToyParser* p, KitCgTypeId type);
 KitCgTypeId toy_emit_var_lvalue(ToyParser* p, KitSym name);
 
 static void toy_note_cg_result_type(ToyParser* p, KitCgTypeId ty) {
   p->last_type = toy_type_from_cg(p, ty);
 }
 
 static void toy_note_builtin_result_type(ToyParser* p, KitCgTypeId ty) {
   KitCgTypeId last_cg = toy_type_resolved_cg(p, p->last_type);
   if (last_cg != ty) toy_note_cg_result_type(p, ty);
 }
 
 static int toy_reject_tail_call_operand(ToyParser* p) {
   if (!p->tail_call_expr) return 0;
   toy_error(p, p->cur.loc, "tail @call must be returned directly");
   return 1;
 }
 
 KitCgTypeId toy_push_named_rvalue(ToyParser* p, KitSym name) {
   ToyVar* v = toy_find_var(p, name);
   if (v) {
     if (kit_cg_type_kind(p->c, v->type) == KIT_CG_TYPE_RECORD) {
       /* Record: leave the address (pointer VALUE) for the caller's copy. */
       toy_push_var_lvalue(p, v);
     } else if (v->is_static) {
       /* Static scalar: its address is a pointer; deref to a place, then load.
        */
       kit_cg_push_symbol_addr(p->cg, v->static_sym, 0);
       kit_cg_deref(p->cg, 0);
       kit_cg_load(p->cg, toy_mem_access(p, v->type));
     } else {
       /* Local scalar: the local's PLACE loads directly (no address round-trip,
        * which keeps small accessors inlinable). */
       kit_cg_push_local(p->cg, v->local);
       kit_cg_load(p->cg, toy_mem_access(p, v->type));
     }
     p->last_type = v->toy_type;
     return v->type;
   }
   {
     ToyGlobal* g = toy_find_global(p, name);
     if (g) {
       kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
       if (kit_cg_type_kind(p->c, g->type) != KIT_CG_TYPE_RECORD) {
         kit_cg_deref(p->cg, 0);
         kit_cg_load(p->cg, toy_mem_access(p, g->type));
       }
       p->last_type = g->toy_type;
       return g->type;
     }
   }
   {
     ToyFn* fn = toy_find_fn(p, name);
     if (fn) {
       KitCgTypeId ptr_ty = kit_cg_type_ptr(p->c, fn->type, 0);
       kit_cg_push_symbol_addr(p->cg, toy_fn_cur_sym(p, fn), 0);
       p->last_type = toy_type_register_ptr(p, ptr_ty, fn->toy_type, 0);
       return ptr_ty;
     }
   }
   return KIT_CG_TYPE_NONE;
 }
 
 int toy_parse_call_args(ToyParser* p, ToyToken call_tok, KitCgTypeId fn_ty,
                         const ToyTypeId* toy_params, size_t toy_nparams,
                         size_t* out_nargs) {
   uint32_t nparams = kit_cg_type_func_nparams(p->c, fn_ty);
   int variadic = kit_cg_type_func_is_variadic(p->c, fn_ty);
   size_t nargs = 0;
   if (p->cur.kind != TOK_RPAREN) {
     for (;;) {
       KitCgTypeId arg_ty;
       if (nargs < nparams && p->cur.kind == TOK_DOT) {
         KitCgFuncParam param =
             kit_cg_type_func_param(p->c, fn_ty, (uint32_t)nargs);
         ToyNamedType* named = toy_find_named_type_by_type(p, param.type);
         KitSym value_name;
         size_t i;
         int found = 0;
         int64_t value = 0;
         toy_parser_advance(p); /* . */
         if (p->cur.kind != TOK_IDENT) {
           toy_error(p, p->cur.loc, "expected enum value");
           return 0;
         }
         value_name = toy_tok_sym(p, p->cur);
         toy_parser_advance(p);
         if (!named || named->kind != TOY_NAMED_ENUM) {
           toy_error(p, p->cur.loc, "dot argument requires enum parameter");
           return 0;
         }
         for (i = 0; i < named->nenum_values; ++i) {
           if (named->enum_values[i].name == value_name) {
             found = 1;
             value = named->enum_values[i].value;
             break;
           }
         }
         if (!found) {
           toy_error(p, p->cur.loc, "unknown enum value");
           return 0;
         }
         kit_cg_push_int(p->cg, (uint64_t)value, param.type);
         arg_ty = param.type;
         p->last_type = (toy_params && nargs < toy_nparams)
                            ? toy_params[nargs]
                            : toy_type_from_cg(p, arg_ty);
       } else {
         arg_ty = toy_parse_expr(p);
       }
       if (arg_ty == KIT_CG_TYPE_NONE) return 0;
       if (toy_reject_tail_call_operand(p)) return 0;
       if (nargs < nparams) {
         KitCgFuncParam param =
             kit_cg_type_func_param(p->c, fn_ty, (uint32_t)nargs);
         ToyTypeId expected = (toy_params && nargs < toy_nparams)
                                  ? toy_params[nargs]
                                  : TOY_TYPE_NONE;
         ToyTypeId actual = p->last_type;
         if (expected != TOY_TYPE_NONE &&
             !toy_type_accepts_type(p, expected, actual)) {
           toy_error(p, call_tok.loc, "function argument type mismatch");
           return 0;
         }
         if (expected == TOY_TYPE_NONE &&
             !toy_type_can_implicitly_cast(p, arg_ty, param.type)) {
           toy_error(p, call_tok.loc, "function argument type mismatch");
           return 0;
         }
         if (arg_ty != param.type) {
           if (expected != TOY_TYPE_NONE) {
             if (!toy_emit_checked_cast(p, arg_ty, param.type)) return 0;
           } else if (!toy_emit_implicit_cast(p, arg_ty, param.type)) {
             return 0;
           }
         }
       } else if (!variadic) {
         toy_error(p, call_tok.loc, "too many arguments");
         return 0;
       }
       nargs++;
       if (!toy_parser_match(p, TOK_COMMA)) break;
     }
   }
   if (!toy_parser_expect(p, TOK_RPAREN)) {
     toy_error(p, p->cur.loc, "expected ')' after arguments");
     return 0;
   }
   if (nargs < nparams) {
     toy_error(p, call_tok.loc, "too few arguments");
     return 0;
   }
   *out_nargs = nargs;
   return 1;
 }
 
 KitCgMemAccess toy_mem_access(ToyParser* p, KitCgTypeId type) {
   KitCgMemAccess access;
   (void)p;
   memset(&access, 0, sizeof access);
   access.type = type;
   return access;
 }
 
 static int toy_type_is_promotable_int(ToyParser* p, KitCgTypeId ty) {
   return kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_INT;
 }
 
 static KitCgTypeId toy_int_literal_type(ToyParser* p, int64_t value) {
   if (value <= INT8_MAX) return toy_builtin_type(p, KIT_CG_BUILTIN_I8);
   if (value <= INT16_MAX) return toy_builtin_type(p, KIT_CG_BUILTIN_I16);
   if (value <= INT32_MAX) return toy_builtin_type(p, KIT_CG_BUILTIN_I32);
   return toy_builtin_type(p, KIT_CG_BUILTIN_I64);
 }
 
 int toy_type_can_implicitly_cast(ToyParser* p, KitCgTypeId src,
                                  KitCgTypeId dst) {
   KitCgTypeKind sk, dk;
   if (src == dst) return 1;
   sk = kit_cg_type_kind(p->c, src);
   dk = kit_cg_type_kind(p->c, dst);
   if (sk == KIT_CG_TYPE_INT && dk == KIT_CG_TYPE_INT)
     return toy_type_int_width(p, src) <= toy_type_int_width(p, dst);
   if (sk == KIT_CG_TYPE_FLOAT && dk == KIT_CG_TYPE_FLOAT)
     return kit_cg_type_float_width(p->c, src) <=
            kit_cg_type_float_width(p->c, dst);
   return 0;
 }
 
 int toy_emit_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst) {
   KitCgTypeKind sk, dk;
   if (src == dst) return 1;
   sk = kit_cg_type_kind(p->c, src);
   dk = kit_cg_type_kind(p->c, dst);
 
   if (dk == KIT_CG_TYPE_BOOL && toy_type_is_intlike(p, src)) {
     kit_cg_push_int(p->cg, 0, src);
     kit_cg_int_cmp(p->cg, KIT_CG_INT_NE);
     return 1;
   }
   if (toy_type_is_intlike(p, src) && toy_type_is_intlike(p, dst)) {
     uint32_t sw = toy_type_int_width(p, src);
     uint32_t dw = toy_type_int_width(p, dst);
     if (dw > sw && sk == KIT_CG_TYPE_BOOL)
       kit_cg_zext(p->cg, dst);
     else if (dw > sw)
       kit_cg_sext(p->cg, dst);
     else if (dw < sw)
       kit_cg_trunc(p->cg, dst);
     return 1;
   }
   if (toy_type_is_intlike(p, src) && dk == KIT_CG_TYPE_FLOAT) {
     kit_cg_sint_to_float(p->cg, dst, KIT_CG_ROUND_DEFAULT);
     return 1;
   }
   if (sk == KIT_CG_TYPE_FLOAT && toy_type_is_intlike(p, dst)) {
     kit_cg_float_to_sint(p->cg, dst, KIT_CG_ROUND_TOWARD_ZERO);
     return 1;
   }
   if (sk == KIT_CG_TYPE_FLOAT && dk == KIT_CG_TYPE_FLOAT) {
     uint32_t sw = kit_cg_type_float_width(p->c, src);
     uint32_t dw = kit_cg_type_float_width(p->c, dst);
     if (dw > sw)
       kit_cg_fpext(p->cg, dst);
     else if (dw < sw)
       kit_cg_fptrunc(p->cg, dst);
     return 1;
   }
   if (sk == KIT_CG_TYPE_PTR && toy_type_is_intlike(p, dst)) {
     kit_cg_ptr_to_int(p->cg, dst);
     return 1;
   }
   if (toy_type_is_intlike(p, src) && dk == KIT_CG_TYPE_PTR) {
     kit_cg_int_to_ptr(p->cg, dst);
     return 1;
   }
   if (sk == KIT_CG_TYPE_PTR && dk == KIT_CG_TYPE_PTR) {
     kit_cg_bitcast(p->cg, dst);
     return 1;
   }
   toy_error(p, p->cur.loc, "unsupported cast");
   return 0;
 }
 
 int toy_emit_implicit_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst) {
   if (src == dst) return 1;
   if (!toy_type_can_implicitly_cast(p, src, dst)) {
     toy_error(p, p->cur.loc, "implicit conversion would lose information");
     return 0;
   }
   return toy_emit_cast(p, src, dst);
 }
 
 int toy_emit_checked_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst) {
   KitCgTypeKind sk, dk;
   if (src == dst) return 1;
   if (toy_type_can_implicitly_cast(p, src, dst))
     return toy_emit_cast(p, src, dst);
   sk = kit_cg_type_kind(p->c, src);
   dk = kit_cg_type_kind(p->c, dst);
   if (sk == KIT_CG_TYPE_PTR && dk == KIT_CG_TYPE_PTR) {
     kit_cg_bitcast(p->cg, dst);
     return 1;
   }
   toy_error(p, p->cur.loc, "unsupported checked conversion");
   return 0;
 }
 
 static int toy_promote_right_operand(ToyParser* p, KitCgTypeId src,
                                      KitCgTypeId dst) {
   return toy_emit_implicit_cast(p, src, dst);
 }
 
 static int toy_promote_left_operand(ToyParser* p, KitCgTypeId src,
                                     KitCgTypeId dst) {
   kit_cg_swap(p->cg);
   if (!toy_emit_implicit_cast(p, src, dst)) return 0;
   kit_cg_swap(p->cg);
   return 1;
 }
 
 static int toy_promote_binary_int_operands(ToyParser* p, KitCgTypeId* left,
                                            KitCgTypeId* right) {
   uint32_t lw, rw;
   if (*left == *right) return 1;
   if (!toy_type_is_promotable_int(p, *left) ||
       !toy_type_is_promotable_int(p, *right))
     return 0;
   lw = toy_type_int_width(p, *left);
   rw = toy_type_int_width(p, *right);
   if (lw < rw) {
     if (!toy_promote_left_operand(p, *left, *right)) return 0;
     *left = *right;
   } else if (rw < lw) {
     if (!toy_promote_right_operand(p, *right, *left)) return 0;
     *right = *left;
   } else {
     return 0;
   }
   return 1;
 }
 
 KitCgLocalAttrs toy_slot_attrs(KitSym name) {
   KitCgLocalAttrs attrs;
   memset(&attrs, 0, sizeof attrs);
   attrs.name = name;
   return attrs;
 }
 
 KitSym toy_c_linkage_name(ToyParser* p, KitSym source_name) {
   KitSym linkage_name = kit_cg_c_linkage_name(p->c, source_name);
   if (!linkage_name) {
     toy_error(p, p->cur.loc, "failed to create linkage name");
   }
   return linkage_name;
 }
 
 void toy_inline_asm(ToyParser* p, KitSym tmpl, const KitCgAsmOperand* outputs,
                     uint32_t noutputs, const KitCgAsmOperand* inputs,
                     uint32_t ninputs, const KitSym* clobbers,
                     uint32_t nclobbers, uint32_t flags,
                     uint32_t clobber_abi_sets) {
   KitCgInlineAsm asm_block;
   memset(&asm_block, 0, sizeof asm_block);
   asm_block.tmpl = tmpl;
   asm_block.outputs = outputs;
   asm_block.noutputs = noutputs;
   asm_block.inputs = inputs;
   asm_block.ninputs = ninputs;
   asm_block.clobbers = clobbers;
   asm_block.nclobbers = nclobbers;
   asm_block.flags = flags;
   asm_block.clobber_abi_sets = clobber_abi_sets;
   kit_cg_inline_asm(p->cg, asm_block);
 }
 
 int toy_emit_truthy(ToyParser* p, KitCgTypeId type) {
   if (type == toy_builtin_type(p, KIT_CG_BUILTIN_BOOL)) return 1;
   if (toy_type_is_intlike(p, type)) {
     kit_cg_push_int(p->cg, 0, type);
     kit_cg_int_cmp(p->cg, KIT_CG_INT_NE);
     return 1;
   }
   toy_error(p, p->cur.loc, "condition must be int or bool");
   return 0;
 }
 
 static int toy_note_expr_island(ToyParser* p, ToyExprIsland island) {
   uint32_t prior = p->expr_island_mask;
   if (prior && prior != (uint32_t)island) {
     toy_error(p, p->cur.loc, "mixed precedence islands require parentheses");
     return 0;
   }
   p->expr_island_mask |= (uint32_t)island;
   return 1;
 }
 
 int toy_expect_comma(ToyParser* p) {
   if (!toy_parser_expect(p, TOK_COMMA)) {
     toy_error(p, p->cur.loc, "expected ','");
     return 0;
   }
   return 1;
 }
 
 static int toy_parse_dot_constant_value(ToyParser* p, int64_t* out) {
   KitSym name;
   if (!toy_parser_expect(p, TOK_DOT) || p->cur.kind != TOK_IDENT) {
     toy_error(p, p->cur.loc, "expected dot constant");
     return 0;
   }
   name = toy_tok_sym(p, p->cur);
   toy_parser_advance(p);
   if (toy_sym_is(p, name, "arm64"))
     *out = 1;
   else if (toy_sym_is(p, name, "x64"))
     *out = 2;
   else if (toy_sym_is(p, name, "rv64"))
     *out = 3;
   else if (toy_sym_is(p, name, "x86"))
     *out = 4;
   else if (toy_sym_is(p, name, "arm32"))
     *out = 5;
   else if (toy_sym_is(p, name, "rv32"))
     *out = 6;
   else if (toy_sym_is(p, name, "wasm"))
     *out = 7;
   else {
     toy_error(p, p->cur.loc, "unknown dot constant");
     return 0;
   }
   return 1;
 }
 
 int toy_parse_switch_label_value(ToyParser* p, KitCgTypeId selector_ty,
                                  int64_t* out) {
   ToyNamedType* named;
   KitSym value_name;
   size_t i;
   if (p->cur.kind != TOK_DOT) return toy_parse_number_arg(p, out);
   named = toy_find_named_type_by_type(p, selector_ty);
   if (!named || named->kind != TOY_NAMED_ENUM)
     return toy_parse_dot_constant_value(p, out);
   toy_parser_advance(p); /* . */
   if (p->cur.kind != TOK_IDENT) {
     toy_error(p, p->cur.loc, "expected enum value");
     return 0;
   }
   value_name = toy_tok_sym(p, p->cur);
   toy_parser_advance(p);
   for (i = 0; i < named->nenum_values; ++i) {
     if (named->enum_values[i].name == value_name) {
       *out = named->enum_values[i].value;
       return 1;
     }
   }
   toy_error(p, p->cur.loc, "unknown enum value");
   return 0;
 }
 
 int toy_parse_symbol_feature_const(ToyParser* p, KitCgSymbolFeature* out) {
   static const ToyConstRow rows[] = {
       {"weak", KIT_CG_SYMFEAT_WEAK},
       {"protected_visibility", KIT_CG_SYMFEAT_PROTECTED_VISIBILITY},
       {"dllimport", KIT_CG_SYMFEAT_DLLIMPORT},
       {"dllexport", KIT_CG_SYMFEAT_DLLEXPORT},
       {"comdat", KIT_CG_SYMFEAT_COMDAT},
       {"common", KIT_CG_SYMFEAT_COMMON},
       {"merge_sections", KIT_CG_SYMFEAT_MERGE_SECTIONS},
       {"constructor_priority", KIT_CG_SYMFEAT_CONSTRUCTOR_PRIORITY},
       {"tls_local_exec", KIT_CG_SYMFEAT_TLS_LOCAL_EXEC},
       {"tls_initial_exec", KIT_CG_SYMFEAT_TLS_INITIAL_EXEC},
       {"tls_local_dynamic", KIT_CG_SYMFEAT_TLS_LOCAL_DYNAMIC},
       {"tls_general_dynamic", KIT_CG_SYMFEAT_TLS_GENERAL_DYNAMIC},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 1,
                            "symbol feature", "symbol feature", &v))
     return 0;
   *out = (KitCgSymbolFeature)v;
   return 1;
 }
 
 int toy_parse_backend_feature_const(ToyParser* p, uint64_t* out) {
   static const ToyConstRow rows[] = {
       {"unaligned_memory", KIT_CG_BACKEND_UNALIGNED_MEMORY},
       {"strict_alignment", KIT_CG_BACKEND_STRICT_ALIGNMENT},
       {"red_zone", KIT_CG_BACKEND_RED_ZONE},
       {"simd", KIT_CG_BACKEND_SIMD},
       {"pointer_auth", KIT_CG_BACKEND_POINTER_AUTH},
       {"branch_protection", KIT_CG_BACKEND_BRANCH_PROTECTION},
   };
   return toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 1,
                              "backend feature", "backend feature", out);
 }
 
 int toy_parse_intrinsic_const(ToyParser* p, KitCgIntrinsic* out) {
   static const ToyConstRow rows[] = {
       {"cpu_nop", KIT_CG_INTRIN_CPU_NOP},
       {"cpu_yield", KIT_CG_INTRIN_CPU_YIELD},
       {"wfi", KIT_CG_INTRIN_WFI},
       {"wfe", KIT_CG_INTRIN_WFE},
       {"sev", KIT_CG_INTRIN_SEV},
       {"isb", KIT_CG_INTRIN_ISB},
       {"dmb", KIT_CG_INTRIN_DMB},
       {"dsb", KIT_CG_INTRIN_DSB},
       {"irq_save", KIT_CG_INTRIN_IRQ_SAVE},
       {"irq_restore", KIT_CG_INTRIN_IRQ_RESTORE},
       {"irq_enable", KIT_CG_INTRIN_IRQ_ENABLE},
       {"irq_disable", KIT_CG_INTRIN_IRQ_DISABLE},
       {"syscall", KIT_CG_INTRIN_SYSCALL},
       {"coro_switch", KIT_CG_INTRIN_CORO_SWITCH},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 1,
                            "intrinsic name", "intrinsic", &v))
     return 0;
   *out = (KitCgIntrinsic)v;
   return 1;
 }
 
 int toy_parse_rounding_const(ToyParser* p, KitCgRounding* out) {
   static const ToyConstRow rows[] = {
       {"default", KIT_CG_ROUND_DEFAULT},
       {"nearest_even", KIT_CG_ROUND_NEAREST_EVEN},
       {"toward_zero", KIT_CG_ROUND_TOWARD_ZERO},
       {"down", KIT_CG_ROUND_DOWN},
       {"up", KIT_CG_ROUND_UP},
   };
   uint64_t v;
   if (!toy_parse_dot_const(p, rows, sizeof rows / sizeof rows[0], 0, NULL,
                            "rounding mode", &v))
     return 0;
   *out = (KitCgRounding)v;
   return 1;
 }
 
 int toy_validate_bit_range(ToyParser* p, KitCgTypeId ty, int64_t lo,
                            int64_t width, int allow_full_width) {
   uint32_t type_width;
   if (!toy_type_is_intlike(p, ty) || lo < 0 || width <= 0) return 0;
   type_width = toy_type_int_width(p, ty);
   if (width > (int64_t)type_width) return 0;
   if (!allow_full_width && width >= 64) return 0;
   if (lo > (int64_t)type_width || width > (int64_t)type_width - lo) return 0;
   return 1;
 }
 
 int toy_target_code(ToyParser* p) {
   switch (p->target.arch) {
     case KIT_ARCH_ARM_64:
       return 1;
     case KIT_ARCH_X86_64:
       return 2;
     case KIT_ARCH_RV64:
       return 3;
     case KIT_ARCH_RV32:
       return 6;
     case KIT_ARCH_ARM_32:
       return 5; /* matches the `.arm32` dot-constant selector */
     case KIT_ARCH_WASM:
       return 7;
     default:
       return 0;
   }
 }
 
 int toy_parse_arch_string(ToyParser* p, KitSym* out, size_t* len_out) {
   if (p->cur.kind == TOK_STRING) return toy_parse_string_sym(p, out, len_out);
 
   toy_error(p, p->cur.loc, "expected asm template");
   return 0;
 }
 
 static int toy_emit_var_addr(ToyParser* p, KitSym name) {
   ToyVar* v = toy_find_var(p, name);
   if (v) {
     toy_push_var_addr(p, v);
     return 1;
   }
   {
     ToyGlobal* g = toy_find_global(p, name);
     if (g) {
       kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
       return 1;
     }
   }
   return 0;
 }
 
 KitCgTypeId toy_emit_var_lvalue(ToyParser* p, KitSym name) {
   ToyVar* v = toy_find_var(p, name);
   if (v) {
     toy_push_var_lvalue(p, v);
     return v->type;
   }
   {
     ToyGlobal* g = toy_find_global(p, name);
     if (g) {
       kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
       return g->type;
     }
   }
   return KIT_CG_TYPE_NONE;
 }
 
 static KitCgTypeId toy_type_id_cg_or_none(ToyParser* p, ToyTypeId id) {
   KitCgTypeId ty = toy_type_resolved_cg(p, id);
   return ty != KIT_CG_TYPE_NONE ? ty : toy_type_cg(p, id);
 }
 
 static void toy_store_tos_to_local(ToyParser* p, KitCgLocal local,
                                    KitCgTypeId ty) {
   kit_cg_push_local(p->cg, local);
   kit_cg_swap(p->cg);
   kit_cg_store(p->cg, toy_mem_access(p, ty));
 }
 
 /* Consumes [slice_base, idx] where slice_base is a pointer to the slice
  * record. Produces [elem_ptr] -- a pointer-rvalue to the element. */
 KitCgTypeId toy_emit_slice_index_lvalue(ToyParser* p, KitCgTypeId slice_ty,
                                         ToyTypeId slice_toy_type,
                                         ToyTypeId* elem_toy_out) {
   ToyTypeId elem_toy = toy_type_slice_elem(p, slice_toy_type);
   KitCgTypeId elem_ty = toy_type_id_cg_or_none(p, elem_toy);
   const KitCgRecordLayout* L = kit_cg_type_record_layout(p->c, slice_ty);
   KitCgLocal idx_slot;
   uint64_t ptr_field_off;
   KitCgTypeId ptr_field_type;
   if (elem_ty == KIT_CG_TYPE_NONE ||
       kit_cg_type_kind(p->c, slice_ty) != KIT_CG_TYPE_RECORD || !L ||
       L->nfields < 1) {
     toy_error(p, p->cur.loc, "cannot index non-array/non-pointer");
     return KIT_CG_TYPE_NONE;
   }
   ptr_field_off = L->fields[0].offset;
   ptr_field_type = L->fields[0].type;
   /* Stash the index, then load the slice's ptr field, then re-push idx
    * and compute element pointer. */
   idx_slot = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
   toy_store_tos_to_local(p, idx_slot, p->size_type);
   kit_cg_deref(p->cg, (int64_t)ptr_field_off);
   kit_cg_load(p->cg, toy_mem_access(p, ptr_field_type));
   kit_cg_push_local(p->cg, idx_slot);
   kit_cg_load(p->cg, toy_mem_access(p, p->size_type));
   toy_addr_index(p, kit_cg_type_size(p->c, elem_ty),
                  kit_cg_type_ptr(p->c, elem_ty, 0));
   if (elem_toy_out) *elem_toy_out = elem_toy;
   return elem_ty;
 }
 
 KitCgTypeId toy_emit_slice_value(ToyParser* p, KitCgTypeId base_ty,
                                  ToyTypeId base_toy_type, KitCgTypeId start_ty,
                                  KitCgTypeId end_ty, ToyTypeId* slice_toy_out) {
   ToyTypeId elem_toy = TOY_TYPE_NONE;
   KitCgTypeId elem_ty = KIT_CG_TYPE_NONE;
   ToyTypeId slice_toy;
   KitCgTypeId slice_ty;
   KitCgTypeId ptr_field_type = KIT_CG_TYPE_NONE;
   KitCgLocal start_slot;
   KitCgLocal end_slot;
   KitCgLocal result_slot;
 
   if (start_ty != p->size_type || end_ty != p->size_type) {
     toy_error(p, p->cur.loc, "slice bounds must be isize");
     return KIT_CG_TYPE_NONE;
   }
 
   if (kit_cg_type_kind(p->c, base_ty) == KIT_CG_TYPE_ARRAY) {
     elem_ty = kit_cg_type_array_elem(p->c, base_ty);
     elem_toy = toy_type_array_elem(p, base_toy_type);
   } else if (toy_type_is_slice(p, base_toy_type)) {
     elem_toy = toy_type_slice_elem(p, base_toy_type);
     elem_ty = toy_type_id_cg_or_none(p, elem_toy);
   }
   if (elem_toy == TOY_TYPE_NONE && elem_ty != KIT_CG_TYPE_NONE)
     elem_toy = toy_type_from_cg(p, elem_ty);
   if (elem_ty == KIT_CG_TYPE_NONE || elem_toy == TOY_TYPE_NONE) {
     toy_error(p, p->cur.loc, "cannot slice non-array/non-slice");
     return KIT_CG_TYPE_NONE;
   }
 
   slice_toy = toy_type_register_slice(p, elem_ty, elem_toy);
   slice_ty = toy_type_cg(p, slice_toy);
   {
     uint64_t ptr_off = 0;
     uint64_t len_off = 0;
     const KitCgRecordLayout* L = kit_cg_type_record_layout(p->c, slice_ty);
     if (slice_ty == KIT_CG_TYPE_NONE || !L || L->nfields < 2) {
       toy_error(p, p->cur.loc, "failed to create slice type");
       return KIT_CG_TYPE_NONE;
     }
     ptr_off = L->fields[0].offset;
     ptr_field_type = L->fields[0].type;
     len_off = L->fields[1].offset;
 
     end_slot = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
     toy_store_tos_to_local(p, end_slot, p->size_type);
     start_slot = kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
     toy_store_tos_to_local(p, start_slot, p->size_type);
 
     result_slot = kit_cg_local(p->cg, slice_ty, toy_slot_attrs(0));
     /* TOS = [base] (slice lvalue/pointer or array lvalue/pointer). */
     if (toy_type_is_slice(p, base_toy_type)) {
       /* Replace slice base with its data pointer (a pointer-rvalue). */
       kit_cg_deref(p->cg, (int64_t)ptr_off);
       kit_cg_load(p->cg, toy_mem_access(p, ptr_field_type));
     } else {
       /* Array base: TOS is a pointer-rvalue (callers always project
        * to a pointer for array/slice bases now). Bitcast to *elem. */
       kit_cg_bitcast(p->cg, kit_cg_type_ptr(p->c, elem_ty, 0));
     }
     /* Compute (base + start * sizeof(elem)) as a pointer to the slice's
      * first element. */
     kit_cg_push_local(p->cg, start_slot);
     kit_cg_load(p->cg, toy_mem_access(p, p->size_type));
     toy_addr_index(p, kit_cg_type_size(p->c, elem_ty),
                    kit_cg_type_ptr(p->c, elem_ty, 0));
     /* Store the data pointer into result_slot.ptr. */
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_addr(p->cg);
     kit_cg_deref(p->cg, (int64_t)ptr_off);
     kit_cg_swap(p->cg);
     kit_cg_store(p->cg, toy_mem_access(p, ptr_field_type));
 
     /* len = end - start; store into result_slot.len. */
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_addr(p->cg);
     kit_cg_deref(p->cg, (int64_t)len_off);
     kit_cg_push_local(p->cg, end_slot);
     kit_cg_load(p->cg, toy_mem_access(p, p->size_type));
     kit_cg_push_local(p->cg, start_slot);
     kit_cg_load(p->cg, toy_mem_access(p, p->size_type));
     kit_cg_int_binop(p->cg, KIT_CG_INT_SUB, 0);
     kit_cg_store(p->cg, toy_mem_access(p, p->size_type));
   }
 
   /* Hand back the slice record as a pointer VALUE (its address), matching the
    * "records/slices are pointer VALUEs" shape the downstream record-copy and
    * slice-index paths consume. */
   kit_cg_push_local_addr(p->cg, result_slot);
   if (slice_toy_out) *slice_toy_out = slice_toy;
   p->last_type = slice_toy;
   return slice_ty;
 }
 
 int toy_parse_va_list_addr_arg(ToyParser* p) {
   KitSym name;
   ToyVar* v;
   if (p->cur.kind != TOK_IDENT) {
     toy_error(p, p->cur.loc, "expected va_list identifier");
     return 0;
   }
   name = toy_tok_sym(p, p->cur);
   v = toy_find_var(p, name);
   if (!v || v->type != p->va_list_type) {
     toy_error(p, p->cur.loc, "expected va_list local");
     return 0;
   }
   toy_parser_advance(p);
   return toy_emit_var_addr(p, name);
 }
 
 static KitCgTypeId toy_parse_expr_primary(ToyParser* p) {
   toy_set_loc(p);
   if (p->cur.kind == TOK_AT) {
     KitSym name;
     ToyToken at_tok = p->cur;
     toy_parser_advance(p);
     if (p->cur.kind != TOK_IDENT) {
       toy_error(p, p->cur.loc, "expected builtin name after '@'");
       return KIT_CG_TYPE_NONE;
     }
     name = toy_tok_sym(p, p->cur);
     toy_parser_advance(p);
 
     if (p->cur.kind == TOK_LT) {
       int recognized = 0;
       KitCgTypeId builtin_ty = toy_parse_generic_builtin(p, name, &recognized);
       if (recognized) {
         if (builtin_ty != KIT_CG_TYPE_NONE)
           toy_note_builtin_result_type(p, builtin_ty);
         return builtin_ty;
       }
     }
 
     if (p->cur.kind == TOK_LPAREN) {
       int recognized = 0;
       KitCgTypeId builtin_ty = toy_parse_builtin_call(p, name, &recognized);
       if (recognized) {
         if (builtin_ty != KIT_CG_TYPE_NONE)
           toy_note_builtin_result_type(p, builtin_ty);
         return builtin_ty;
       }
     }
 
     toy_error(p, at_tok.loc, "unknown builtin");
     return KIT_CG_TYPE_NONE;
   }
 
   if (p->cur.kind == TOK_NUMBER) {
     if (p->cur.is_float) {
       kit_cg_push_float(p->cg, p->cur.float_value,
                         toy_builtin_type(p, KIT_CG_BUILTIN_F64));
       toy_parser_advance(p);
       p->last_type =
           toy_type_from_cg(p, toy_builtin_type(p, KIT_CG_BUILTIN_F64));
       return toy_builtin_type(p, KIT_CG_BUILTIN_F64);
     }
     {
       KitCgTypeId lit_ty = toy_int_literal_type(p, p->cur.int_value);
       kit_cg_push_int(p->cg, (uint64_t)p->cur.int_value, lit_ty);
       toy_parser_advance(p);
       p->last_type = toy_type_from_cg(p, lit_ty);
       return lit_ty;
     }
   }
 
   if (p->cur.kind == TOK_IDENT) {
     KitSym name = toy_tok_sym(p, p->cur);
     ToyToken ident_tok = p->cur;
     toy_parser_advance(p);
 
     if (toy_sym_is(p, name, "true") || toy_sym_is(p, name, "false")) {
       kit_cg_push_int(p->cg, toy_sym_is(p, name, "true") ? 1u : 0u,
                       toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
       p->last_type =
           toy_type_from_cg(p, toy_builtin_type(p, KIT_CG_BUILTIN_BOOL));
       return toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
     }
 
     if (toy_sym_is(p, name, "NULL")) {
       kit_cg_push_int(p->cg, 0, p->int_type);
       p->last_type = TOY_TYPE_NONE;
       return p->int_type;
     }
 
     if (p->cur.kind == TOK_LT) {
       int recognized = 0;
       KitCgTypeId builtin_ty = toy_parse_generic_builtin(p, name, &recognized);
       if (recognized) return builtin_ty;
     }
 
     if (p->cur.kind == TOK_LPAREN) {
       /* Function call */
       int recognized = 0;
       KitCgTypeId builtin_ty = toy_parse_builtin_call(p, name, &recognized);
       if (recognized) return builtin_ty;
 
       ToyFn* fn = toy_find_fn(p, name);
       toy_parser_advance(p); /* ( */
 
       size_t nargs = 0;
       if (fn) {
         if (!toy_parse_call_args(p, ident_tok, fn->type, fn->toy_params,
                                  fn->nparams, &nargs))
           return KIT_CG_TYPE_NONE;
         {
           KitCgCallAttrs attrs;
           memset(&attrs, 0, sizeof attrs);
           attrs.inline_policy = fn->func_attrs.inline_policy;
           kit_cg_call_symbol(p->cg, toy_fn_cur_sym(p, fn), (uint32_t)nargs,
                              attrs);
         }
         /* An aggregate return is a PLACE; project it to a pointer VALUE so it
          * matches the records-are-pointers invariant used downstream. */
         if (kit_cg_type_kind(p->c, fn->ret) == KIT_CG_TYPE_RECORD)
           kit_cg_addr(p->cg);
         p->last_type = fn->toy_ret;
         return fn->ret;
       }
 
       KitCgTypeId callee_ty = toy_push_named_rvalue(p, name);
       ToyTypeId callee_toy_type = p->last_type;
       const ToyType* source_fn_type = NULL;
       if (callee_ty == KIT_CG_TYPE_NONE) {
         toy_error(p, ident_tok.loc, "undefined function '%.*s'",
                   (int)ident_tok.text_len, (const char*)ident_tok.text);
         return KIT_CG_TYPE_NONE;
       }
       KitCgTypeId fn_ty = toy_ptr_pointee_func_type(p, callee_ty);
       if (fn_ty == KIT_CG_TYPE_NONE) {
         toy_error(p, ident_tok.loc, "callee is not a function pointer");
         return KIT_CG_TYPE_NONE;
       }
       source_fn_type = toy_type_get(p, toy_type_pointee(p, callee_toy_type));
       if (source_fn_type && source_fn_type->kind != TOY_TYPE_FUNC)
         source_fn_type = NULL;
       if (!toy_parse_call_args(p, ident_tok, fn_ty,
                                source_fn_type ? source_fn_type->params : NULL,
                                source_fn_type ? source_fn_type->nparams : 0,
                                &nargs))
         return KIT_CG_TYPE_NONE;
       kit_cg_call_default(p->cg, (uint32_t)nargs, fn_ty);
       if (kit_cg_type_kind(p->c, toy_cg_func_ret(p, fn_ty)) ==
           KIT_CG_TYPE_RECORD)
         kit_cg_addr(p->cg);
       p->last_type = source_fn_type
                          ? source_fn_type->ret
                          : toy_type_from_cg(p, toy_cg_func_ret(p, fn_ty));
       return toy_cg_func_ret(p, fn_ty);
     }
 
     if (p->cur.kind == TOK_LBRACKET || p->cur.kind == TOK_DOT) {
       ToyVar* v = toy_find_var(p, name);
       if (v && (kit_cg_type_kind(p->c, v->type) == KIT_CG_TYPE_ARRAY ||
                 kit_cg_type_kind(p->c, v->type) == KIT_CG_TYPE_RECORD)) {
         if (kit_cg_type_kind(p->c, v->type) == KIT_CG_TYPE_ARRAY) {
           /* Array slicing/indexing wants a pointer root for address math. */
           toy_push_var_addr(p, v);
         } else {
           toy_push_var_lvalue(p, v);
         }
         p->last_type = v->toy_type;
         return v->type;
       }
       {
         ToyGlobal* g = toy_find_global(p, name);
         if (g && (kit_cg_type_kind(p->c, g->type) == KIT_CG_TYPE_ARRAY ||
                   kit_cg_type_kind(p->c, g->type) == KIT_CG_TYPE_RECORD)) {
           kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
           p->last_type = g->toy_type;
           return g->type;
         }
       }
     }
 
     {
       ToyVar* v = toy_find_var(p, name);
       if (v && toy_type_is_slice(p, v->toy_type)) {
         toy_push_var_lvalue(p, v);
         p->last_type = v->toy_type;
         return v->type;
       }
       {
         ToyGlobal* g = toy_find_global(p, name);
         if (g && toy_type_is_slice(p, g->toy_type)) {
           kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
           p->last_type = g->toy_type;
           return g->type;
         }
       }
     }
 
     {
       KitCgTypeId ty = toy_push_named_rvalue(p, name);
       if (ty != KIT_CG_TYPE_NONE) return ty;
     }
     toy_error(p, ident_tok.loc, "undefined variable '%.*s'",
               (int)ident_tok.text_len, (const char*)ident_tok.text);
     return KIT_CG_TYPE_NONE;
   }
 
   if (p->cur.kind == TOK_LPAREN) {
     toy_parser_advance(p);
     KitCgTypeId ty = toy_parse_expr(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (!toy_parser_expect(p, TOK_RPAREN)) {
       toy_error(p, p->cur.loc, "expected ')'");
       return KIT_CG_TYPE_NONE;
     }
     return ty;
   }
 
   toy_error(p, p->cur.loc, "expected expression");
   return KIT_CG_TYPE_NONE;
 }
 
 static KitCgTypeId toy_parse_expr_postfix(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_primary(p);
   ToyTypeId toy_ty = p->last_type;
   if (p->tail_call_expr) return ty;
   while (ty != KIT_CG_TYPE_NONE) {
     if (toy_parser_match(p, TOK_DOTSTAR)) {
       if (kit_cg_type_kind(p->c, ty) != KIT_CG_TYPE_PTR) {
         toy_error(p, p->cur.loc, "cannot dereference non-pointer");
         return KIT_CG_TYPE_NONE;
       }
       ty = kit_cg_type_ptr_pointee(p->c, ty);
       toy_ty = toy_type_pointee(p, toy_ty);
       /* TOS is a pointer VALUE; deref it to a PLACE, then load. */
       kit_cg_deref(p->cg, 0);
       kit_cg_load(p->cg, toy_mem_access(p, ty));
       p->last_type = toy_ty != TOY_TYPE_NONE ? toy_ty : toy_type_from_cg(p, ty);
       continue;
     }
 
     if (toy_parser_match(p, TOK_LBRACKET)) {
       KitCgTypeId idx_ty = toy_parse_expr(p);
       if (idx_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
       if (!toy_type_can_implicitly_cast(p, idx_ty, p->size_type)) {
         toy_error(p, p->cur.loc, "index must be isize");
         return KIT_CG_TYPE_NONE;
       }
       if (!toy_emit_implicit_cast(p, idx_ty, p->size_type))
         return KIT_CG_TYPE_NONE;
       idx_ty = p->size_type;
       if (toy_parser_match(p, TOK_COLON)) {
         KitCgTypeId end_ty = toy_parse_expr(p);
         ToyTypeId slice_toy_type = TOY_TYPE_NONE;
         if (end_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
         if (!toy_type_can_implicitly_cast(p, end_ty, p->size_type)) {
           toy_error(p, p->cur.loc, "slice bounds must be isize");
           return KIT_CG_TYPE_NONE;
         }
         if (!toy_emit_implicit_cast(p, end_ty, p->size_type))
           return KIT_CG_TYPE_NONE;
         end_ty = p->size_type;
         if (!toy_parser_expect(p, TOK_RBRACKET)) {
           toy_error(p, p->cur.loc, "expected ']' after slice");
           return KIT_CG_TYPE_NONE;
         }
         ty = toy_emit_slice_value(p, ty, toy_ty, idx_ty, end_ty,
                                   &slice_toy_type);
         if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
         toy_ty = slice_toy_type;
         p->last_type = toy_ty;
         continue;
       }
       if (!toy_parser_expect(p, TOK_RBRACKET)) {
         toy_error(p, p->cur.loc, "expected ']' after index");
         return KIT_CG_TYPE_NONE;
       }
       if (kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_PTR) {
         KitCgTypeId pointee = kit_cg_type_ptr_pointee(p->c, ty);
         ToyTypeId source_pointee = toy_type_pointee(p, toy_ty);
         if (kit_cg_type_kind(p->c, pointee) == KIT_CG_TYPE_ARRAY) {
           /* TOS = [ptr-to-array, idx]. Cast pointer to *elem so the load
            * can apply the array's elem-scale on the next memop. */
           KitCgTypeId elem_ty = kit_cg_type_array_elem(p->c, pointee);
           kit_cg_swap(p->cg);
           kit_cg_bitcast(p->cg, kit_cg_type_ptr(p->c, elem_ty, 0));
           kit_cg_swap(p->cg);
           ty = elem_ty;
           toy_ty = toy_type_array_elem(p, source_pointee);
         } else {
           ty = pointee;
           toy_ty = source_pointee;
         }
       } else if (kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_ARRAY) {
         /* TOS = [ptr-to-array, idx]. Decay the base to *elem so kit_cg_elem
          * scales by the element size, not the whole array. */
         KitCgTypeId elem_ty = kit_cg_type_array_elem(p->c, ty);
         kit_cg_swap(p->cg);
         kit_cg_bitcast(p->cg, kit_cg_type_ptr(p->c, elem_ty, 0));
         kit_cg_swap(p->cg);
         ty = elem_ty;
         toy_ty = toy_type_array_elem(p, toy_ty);
       } else if (toy_type_is_slice(p, toy_ty)) {
         ty = toy_emit_slice_index_lvalue(p, ty, toy_ty, &toy_ty);
         if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
         /* toy_emit_slice_index_lvalue returns an element pointer VALUE. */
         kit_cg_deref(p->cg, 0);
         kit_cg_load(p->cg, toy_mem_access(p, ty));
         p->last_type =
             toy_ty != TOY_TYPE_NONE ? toy_ty : toy_type_from_cg(p, ty);
         continue;
       } else {
         toy_error(p, p->cur.loc, "cannot index non-array/non-pointer");
         return KIT_CG_TYPE_NONE;
       }
       /* TOS = [base, idx]; elem yields the element PLACE, then load. */
       kit_cg_elem(p->cg, 0);
       kit_cg_load(p->cg, toy_mem_access(p, ty));
       p->last_type = toy_ty != TOY_TYPE_NONE ? toy_ty : toy_type_from_cg(p, ty);
       continue;
     }
 
     if (toy_parser_match(p, TOK_DOT)) {
       KitSym field_name;
       uint32_t i, nfields;
       int found = 0;
       KitCgFieldLayout found_field;
       uint64_t found_off = 0;
       ToyNamedType* named;
       ToyTypeId field_toy_type = TOY_TYPE_NONE;
       if (kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_PTR &&
           kit_cg_type_kind(p->c, kit_cg_type_ptr_pointee(p->c, ty)) ==
               KIT_CG_TYPE_RECORD) {
         /* TOS is a pointer to the record; the memop accepts it directly,
          * so no intermediate op is needed -- we just update `ty`. */
         ty = kit_cg_type_ptr_pointee(p->c, ty);
         toy_ty = toy_type_pointee(p, toy_ty);
       }
       named = toy_find_named_type_by_type(p, ty);
       if (p->cur.kind == TOK_NUMBER && !p->cur.is_float) {
         uint32_t field_index;
         const KitCgRecordLayout* L = kit_cg_type_record_layout(p->c, ty);
         if (kit_cg_type_kind(p->c, ty) != KIT_CG_TYPE_RECORD || !L ||
             p->cur.int_value < 0 || p->cur.int_value >= (int64_t)L->nfields) {
           toy_error(p, p->cur.loc, "invalid tuple field");
           return KIT_CG_TYPE_NONE;
         }
         field_index = (uint32_t)p->cur.int_value;
         toy_parser_advance(p);
         found_field = L->fields[field_index];
         found_off = found_field.offset;
         if (named && field_index < named->nfields)
           field_toy_type = named->fields[field_index].toy_type;
         ty = found_field.type;
         kit_cg_deref(p->cg, (int64_t)found_off);
         kit_cg_load(p->cg, toy_mem_access(p, ty));
         if (field_toy_type != TOY_TYPE_NONE) {
           KitCgTypeId resolved = toy_type_resolved_cg(p, field_toy_type);
           p->last_type = field_toy_type;
           toy_ty = field_toy_type;
           if (resolved != KIT_CG_TYPE_NONE && resolved != ty) {
             if (!toy_emit_checked_cast(p, ty, resolved))
               return KIT_CG_TYPE_NONE;
             ty = resolved;
           }
         } else {
           p->last_type = toy_type_from_cg(p, ty);
           toy_ty = p->last_type;
         }
         continue;
       }
       if (p->cur.kind != TOK_IDENT) {
         toy_error(p, p->cur.loc, "expected field name");
         return KIT_CG_TYPE_NONE;
       }
       field_name = toy_tok_sym(p, p->cur);
       toy_parser_advance(p);
       if (kit_cg_type_kind(p->c, ty) != KIT_CG_TYPE_RECORD) {
         toy_error(p, p->cur.loc, "field access on non-record");
         return KIT_CG_TYPE_NONE;
       }
       {
         const KitCgRecordLayout* L = kit_cg_type_record_layout(p->c, ty);
         nfields = L ? L->nfields : 0;
         memset(&found_field, 0, sizeof found_field);
         for (i = 0; L && i < nfields; ++i) {
           if (L->fields[i].name == field_name) {
             found = 1;
             found_field = L->fields[i];
             found_off = found_field.offset;
             if (named && i < named->nfields)
               field_toy_type = named->fields[i].toy_type;
             break;
           }
         }
       }
       if (!found) {
         toy_error(p, p->cur.loc, "unknown record field");
         return KIT_CG_TYPE_NONE;
       }
       ty = found_field.type;
       kit_cg_deref(p->cg, (int64_t)found_off);
       kit_cg_load(p->cg, toy_mem_access(p, ty));
       if (field_toy_type != TOY_TYPE_NONE) {
         KitCgTypeId resolved = toy_type_resolved_cg(p, field_toy_type);
         p->last_type = field_toy_type;
         toy_ty = field_toy_type;
         if (resolved != KIT_CG_TYPE_NONE && resolved != ty) {
           if (!toy_emit_checked_cast(p, ty, resolved)) return KIT_CG_TYPE_NONE;
           ty = resolved;
         }
       } else {
         p->last_type = toy_type_from_cg(p, ty);
         toy_ty = p->last_type;
       }
       continue;
     }
 
     break;
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_unary(ToyParser* p) {
   toy_set_loc(p);
   if (toy_parser_match(p, TOK_MINUS)) {
     KitCgTypeId ty = toy_parse_expr_unary(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (p->tail_call_expr) {
       toy_error(p, p->cur.loc, "tail @call must be returned directly");
       return KIT_CG_TYPE_NONE;
     }
     if (toy_type_is_float(p, ty)) {
       kit_cg_fp_unop(p->cg, KIT_CG_FP_NEG, 0);
       return ty;
     }
     if (!toy_type_is_intlike(p, ty)) {
       toy_error(p, p->cur.loc, "invalid operand for unary '-'");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_unop(p->cg, KIT_CG_INT_NEG, 0);
     return ty;
   }
 
   if (toy_parser_match(p, TOK_BANG)) {
     KitCgTypeId ty = toy_parse_expr_unary(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (p->tail_call_expr) {
       toy_error(p, p->cur.loc, "tail @call must be returned directly");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_type_is_intlike(p, ty)) {
       toy_error(p, p->cur.loc, "invalid operand for '!'");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_unop(p->cg, KIT_CG_INT_NOT, 0);
     return ty;
   }
 
   if (toy_parser_match(p, TOK_TILDE)) {
     KitCgTypeId ty = toy_parse_expr_unary(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (p->tail_call_expr) {
       toy_error(p, p->cur.loc, "tail @call must be returned directly");
       return KIT_CG_TYPE_NONE;
     }
     if (!toy_type_is_intlike(p, ty)) {
       toy_error(p, p->cur.loc, "invalid operand for '~'");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_unop(p->cg, KIT_CG_INT_BNOT, 0);
     return ty;
   }
 
   if (toy_parser_match(p, TOK_AMPERSAND)) {
     KitSym name;
     KitCgTypeId ty;
     if (p->cur.kind != TOK_IDENT) {
       toy_error(p, p->cur.loc, "expected identifier after '&'");
       return KIT_CG_TYPE_NONE;
     }
     name = toy_tok_sym(p, p->cur);
     toy_parser_advance(p);
 
     if (p->cur.kind == TOK_LBRACKET || p->cur.kind == TOK_DOTSTAR ||
         p->cur.kind == TOK_DOT) {
       /* `&expr` chain. Maintain the invariant that TOS holds a
        * pointer-rvalue of type *ty. The chain returns a pointer-rvalue
        * directly (no trailing kit_cg_addr needed). */
       ToyTypeId ty_toy = TOY_TYPE_NONE;
       {
         ToyVar* v = toy_find_var(p, name);
         ToyGlobal* g = toy_find_global(p, name);
         if (v) {
           toy_push_var_addr(p, v);
           ty = v->type;
           ty_toy = v->toy_type;
         } else if (g) {
           kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
           ty = g->type;
           ty_toy = g->toy_type;
         } else {
           ty = KIT_CG_TYPE_NONE;
         }
       }
       if (ty == KIT_CG_TYPE_NONE) {
         toy_error(p, p->cur.loc, "undefined variable");
         return KIT_CG_TYPE_NONE;
       }
       for (;;) {
         if (toy_parser_match(p, TOK_LBRACKET)) {
           KitCgTypeId idx_ty = toy_parse_expr(p);
           if (idx_ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
           if (!toy_type_can_implicitly_cast(p, idx_ty, p->size_type)) {
             toy_error(p, p->cur.loc, "index must be isize");
             return KIT_CG_TYPE_NONE;
           }
           if (!toy_emit_implicit_cast(p, idx_ty, p->size_type))
             return KIT_CG_TYPE_NONE;
           idx_ty = p->size_type;
           if (!toy_parser_expect(p, TOK_RBRACKET)) {
             toy_error(p, p->cur.loc, "expected ']' after index");
             return KIT_CG_TYPE_NONE;
           }
           if (kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_PTR) {
             KitCgTypeId pointee = kit_cg_type_ptr_pointee(p->c, ty);
             /* TOS holds **T_chain; load the inner pointer first. */
             {
               KitCgLocal idx_slot =
                   kit_cg_local(p->cg, p->size_type, toy_slot_attrs(0));
               kit_cg_push_local(p->cg, idx_slot);
               kit_cg_swap(p->cg);
               kit_cg_store(p->cg, toy_mem_access(p, p->size_type));
               /* TOS is the chain pointer VALUE (**T); deref to a PLACE and
                * load the inner pointer it addresses. */
               kit_cg_deref(p->cg, 0);
               kit_cg_load(p->cg, toy_mem_access(p, ty));
               kit_cg_push_local(p->cg, idx_slot);
               kit_cg_load(p->cg, toy_mem_access(p, p->size_type));
             }
             if (kit_cg_type_kind(p->c, pointee) == KIT_CG_TYPE_ARRAY) {
               KitCgTypeId elem_ty = kit_cg_type_array_elem(p->c, pointee);
               ty = elem_ty;
               ty_toy = toy_type_array_elem(p, toy_type_pointee(p, ty_toy));
               toy_addr_index(p, kit_cg_type_size(p->c, elem_ty),
                              kit_cg_type_ptr(p->c, elem_ty, 0));
             } else {
               ty = pointee;
               ty_toy = toy_type_pointee(p, ty_toy);
               toy_addr_index(p, kit_cg_type_size(p->c, ty),
                              kit_cg_type_ptr(p->c, ty, 0));
             }
           } else if (kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_ARRAY) {
             KitCgTypeId elem_ty = kit_cg_type_array_elem(p->c, ty);
             ty = elem_ty;
             ty_toy = toy_type_array_elem(p, ty_toy);
             toy_addr_index(p, kit_cg_type_size(p->c, elem_ty),
                            kit_cg_type_ptr(p->c, elem_ty, 0));
           } else if (toy_type_is_slice(p, ty_toy)) {
             ToyTypeId elem_toy = TOY_TYPE_NONE;
             ty = toy_emit_slice_index_lvalue(p, ty, ty_toy, &elem_toy);
             if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
             ty_toy = elem_toy;
           } else {
             toy_error(p, p->cur.loc, "cannot index non-array/non-pointer");
             return KIT_CG_TYPE_NONE;
           }
           continue;
         }
         if (toy_parser_match(p, TOK_DOTSTAR)) {
           if (kit_cg_type_kind(p->c, ty) != KIT_CG_TYPE_PTR) {
             toy_error(p, p->cur.loc, "cannot dereference non-pointer");
             return KIT_CG_TYPE_NONE;
           }
           /* TOS = **T (pointer VALUE); deref to PLACE and load to TOS = *T. */
           kit_cg_deref(p->cg, 0);
           kit_cg_load(p->cg, toy_mem_access(p, ty));
           ty = kit_cg_type_ptr_pointee(p->c, ty);
           ty_toy = toy_type_pointee(p, ty_toy);
           continue;
         }
         if (toy_parser_match(p, TOK_DOT)) {
           KitCgFieldLayout field;
           uint32_t field_index = 0;
           uint64_t foff = 0;
           ToyNamedType* named;
           if (kit_cg_type_kind(p->c, ty) == KIT_CG_TYPE_PTR &&
               kit_cg_type_kind(p->c, kit_cg_type_ptr_pointee(p->c, ty)) ==
                   KIT_CG_TYPE_RECORD) {
             /* TOS = **Rec (pointer VALUE); deref to PLACE and load to *Rec. */
             kit_cg_deref(p->cg, 0);
             kit_cg_load(p->cg, toy_mem_access(p, ty));
             ty = kit_cg_type_ptr_pointee(p->c, ty);
             ty_toy = toy_type_pointee(p, ty_toy);
           }
           if (kit_cg_type_kind(p->c, ty) != KIT_CG_TYPE_RECORD) {
             toy_error(p, p->cur.loc, "field access on non-record");
             return KIT_CG_TYPE_NONE;
           }
           named = toy_find_named_type_by_type(p, ty);
           if (p->cur.kind == TOK_NUMBER && !p->cur.is_float) {
             const KitCgRecordLayout* L = kit_cg_type_record_layout(p->c, ty);
             if (!L || p->cur.int_value < 0 ||
                 p->cur.int_value >= (int64_t)L->nfields) {
               toy_error(p, p->cur.loc, "invalid tuple field");
               return KIT_CG_TYPE_NONE;
             }
             field_index = (uint32_t)p->cur.int_value;
             toy_parser_advance(p);
             field = L->fields[field_index];
             foff = field.offset;
           } else {
             KitSym field_name;
             if (p->cur.kind != TOK_IDENT) {
               toy_error(p, p->cur.loc, "expected field name");
               return KIT_CG_TYPE_NONE;
             }
             field_name = toy_tok_sym(p, p->cur);
             toy_parser_advance(p);
             if (!toy_record_field_index(p, ty, field_name, &field_index,
                                         &field)) {
               toy_error(p, p->cur.loc, "unknown record field");
               return KIT_CG_TYPE_NONE;
             }
             foff = field.offset;
           }
           ty = field.type;
           ty_toy = (named && field_index < named->nfields)
                        ? named->fields[field_index].toy_type
                        : toy_type_from_cg(p, ty);
           toy_addr_offset(p, (int64_t)foff, kit_cg_type_ptr(p->c, ty, 0));
           continue;
         }
         break;
       }
       /* TOS already holds a pointer-rvalue of type *ty. */
       {
         KitCgTypeId ptr_ty = kit_cg_type_ptr(p->c, ty, 0);
         p->last_type = toy_type_register_ptr(
             p, ptr_ty,
             ty_toy != TOY_TYPE_NONE ? ty_toy : toy_type_from_cg(p, ty), 0);
         return ptr_ty;
       }
     }
 
     {
       ToyVar* v = toy_find_var(p, name);
       if (v) {
         KitCgTypeId ptr_ty = kit_cg_type_ptr(p->c, v->type, 0);
         toy_push_var_addr(p, v);
         p->last_type = toy_type_register_ptr(p, ptr_ty, v->toy_type, 0);
         return ptr_ty;
       } else {
         ToyGlobal* g = toy_find_global(p, name);
         if (g) {
           KitCgTypeId ptr_ty = kit_cg_type_ptr(p->c, g->type, 0);
           kit_cg_push_symbol_addr(p->cg, toy_global_cur_sym(p, g), 0);
           p->last_type = toy_type_register_ptr(p, ptr_ty, g->toy_type, 0);
           return ptr_ty;
         } else {
           ToyFn* fn = toy_find_fn(p, name);
           if (fn) {
             KitCgTypeId ptr_ty = kit_cg_type_ptr(p->c, fn->type, 0);
             kit_cg_push_symbol_addr(p->cg, toy_fn_cur_sym(p, fn), 0);
             p->last_type = toy_type_register_ptr(p, ptr_ty, fn->toy_type, 0);
             return ptr_ty;
           }
         }
         toy_error(p, p->cur.loc, "undefined variable");
         return KIT_CG_TYPE_NONE;
       }
     }
   }
 
   return toy_parse_expr_postfix(p);
 }
 
 static KitCgTypeId toy_parse_expr_cast(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_unary(p);
   while (ty != KIT_CG_TYPE_NONE && !p->tail_call_expr &&
          toy_parser_match(p, TOK_AS)) {
     KitCgTypeId dst = toy_parse_type(p);
     if (dst == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (!toy_emit_cast(p, ty, dst)) return KIT_CG_TYPE_NONE;
     ty = dst;
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_mul(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_cast(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_STAR || p->cur.kind == TOK_SLASH ||
          p->cur.kind == TOK_PERCENT) {
     if (p->tail_call_expr) break;
     ToyTokenKind op = p->cur.kind;
     KitCgIntBinOp binop;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_ARITH))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_cast(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (toy_type_is_intlike(p, ty) && toy_type_is_intlike(p, ty2)) {
       if (!toy_promote_binary_int_operands(p, &ty, &ty2)) {
         toy_error(p, p->cur.loc,
                   "arithmetic operands must have same numeric type");
         return KIT_CG_TYPE_NONE;
       }
     } else if (ty != ty2 || !toy_type_is_float(p, ty)) {
       toy_error(p, p->cur.loc,
                 "arithmetic operands must have same numeric type");
       return KIT_CG_TYPE_NONE;
     }
     if (toy_type_is_float(p, ty)) {
       KitCgFpBinOp fp_op;
       if (op == TOK_PERCENT) {
         toy_error(p, p->cur.loc, "floating-point remainder is unsupported");
         return KIT_CG_TYPE_NONE;
       }
       switch (op) {
         case TOK_STAR:
           fp_op = KIT_CG_FP_MUL;
           break;
         case TOK_SLASH:
           fp_op = KIT_CG_FP_DIV;
           break;
         default:
           return KIT_CG_TYPE_NONE;
       }
       kit_cg_fp_binop(p->cg, fp_op, 0);
     } else {
       switch (op) {
         case TOK_STAR:
           binop = KIT_CG_INT_MUL;
           break;
         case TOK_SLASH:
           binop = KIT_CG_INT_SDIV;
           break;
         case TOK_PERCENT:
           binop = KIT_CG_INT_SREM;
           break;
         default:
           return KIT_CG_TYPE_NONE;
       }
       kit_cg_int_binop(p->cg, binop, 0);
     }
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_add(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_mul(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_PLUS || p->cur.kind == TOK_MINUS) {
     if (p->tail_call_expr) break;
     ToyTokenKind op = p->cur.kind;
     KitCgIntBinOp binop = (op == TOK_PLUS) ? KIT_CG_INT_ADD : KIT_CG_INT_SUB;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_ARITH))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_mul(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (toy_type_is_intlike(p, ty) && toy_type_is_intlike(p, ty2)) {
       if (!toy_promote_binary_int_operands(p, &ty, &ty2)) {
         toy_error(p, p->cur.loc,
                   "arithmetic operands must have same numeric type");
         return KIT_CG_TYPE_NONE;
       }
     } else if (ty != ty2 || !toy_type_is_float(p, ty)) {
       toy_error(p, p->cur.loc,
                 "arithmetic operands must have same numeric type");
       return KIT_CG_TYPE_NONE;
     }
     if (toy_type_is_float(p, ty)) {
       kit_cg_fp_binop(p->cg, op == TOK_PLUS ? KIT_CG_FP_ADD : KIT_CG_FP_SUB, 0);
     } else {
       kit_cg_int_binop(p->cg, binop, 0);
     }
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_cmp(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_add(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   if (!p->tail_call_expr && (p->cur.kind == TOK_EQEQ || p->cur.kind == TOK_NE ||
                              p->cur.kind == TOK_LT || p->cur.kind == TOK_GT ||
                              p->cur.kind == TOK_LE || p->cur.kind == TOK_GE)) {
     ToyTokenKind op = p->cur.kind;
     KitCgIntCmpOp cmp;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_CMP)) return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_add(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (toy_type_is_intlike(p, ty) && toy_type_is_intlike(p, ty2)) {
       if (!toy_promote_binary_int_operands(p, &ty, &ty2)) {
         toy_error(p, p->cur.loc, "comparison operands must have same type");
         return KIT_CG_TYPE_NONE;
       }
     } else if (ty != ty2) {
       toy_error(p, p->cur.loc, "comparison operands must have same type");
       return KIT_CG_TYPE_NONE;
     }
     if (toy_type_is_float(p, ty)) {
       KitCgFpCmpOp fp_cmp;
       switch (op) {
         case TOK_EQEQ:
           fp_cmp = KIT_CG_FP_OEQ;
           break;
         case TOK_NE:
           /* `!=` on floats is unordered not-equal (true on NaN), not ONE. */
           fp_cmp = KIT_CG_FP_UNE;
           break;
         case TOK_LT:
           fp_cmp = KIT_CG_FP_OLT;
           break;
         case TOK_GT:
           fp_cmp = KIT_CG_FP_OGT;
           break;
         case TOK_LE:
           fp_cmp = KIT_CG_FP_OLE;
           break;
         case TOK_GE:
           fp_cmp = KIT_CG_FP_OGE;
           break;
         default:
           return KIT_CG_TYPE_NONE;
       }
       kit_cg_fp_cmp(p->cg, fp_cmp);
     } else if (toy_type_is_intlike(p, ty) || toy_type_is_ptr(p, ty)) {
       switch (op) {
         case TOK_EQEQ:
           cmp = KIT_CG_INT_EQ;
           break;
         case TOK_NE:
           cmp = KIT_CG_INT_NE;
           break;
         case TOK_LT:
           cmp = KIT_CG_INT_LT_S;
           break;
         case TOK_GT:
           cmp = KIT_CG_INT_GT_S;
           break;
         case TOK_LE:
           cmp = KIT_CG_INT_LE_S;
           break;
         case TOK_GE:
           cmp = KIT_CG_INT_GE_S;
           break;
         default:
           return KIT_CG_TYPE_NONE;
       }
       kit_cg_int_cmp(p->cg, cmp);
     } else {
       toy_error(p, p->cur.loc, "comparison operands must be scalar");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_zext(p->cg, p->int_type);
     ty = p->int_type;
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_shift(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_cmp(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_SHL || p->cur.kind == TOK_SHR) {
     if (p->tail_call_expr) break;
     ToyTokenKind op = p->cur.kind;
     KitCgIntBinOp binop = (op == TOK_SHL) ? KIT_CG_INT_SHL : KIT_CG_INT_ASHR;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_SHIFT))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_cmp(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (!toy_type_is_promotable_int(p, ty) ||
         !toy_type_is_promotable_int(p, ty2) ||
         !toy_promote_binary_int_operands(p, &ty, &ty2)) {
       toy_error(p, p->cur.loc, "shift operands must be int");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_binop(p->cg, binop, 0);
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_band(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_shift(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_AMPERSAND) {
     if (p->tail_call_expr) break;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_BIT_AND))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_shift(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (!toy_type_is_promotable_int(p, ty) ||
         !toy_type_is_promotable_int(p, ty2) ||
         !toy_promote_binary_int_operands(p, &ty, &ty2)) {
       toy_error(p, p->cur.loc, "bitwise operands must be int");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_binop(p->cg, KIT_CG_INT_AND, 0);
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_bxor(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_band(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_CARET) {
     if (p->tail_call_expr) break;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_BIT_XOR))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_band(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (!toy_type_is_promotable_int(p, ty) ||
         !toy_type_is_promotable_int(p, ty2) ||
         !toy_promote_binary_int_operands(p, &ty, &ty2)) {
       toy_error(p, p->cur.loc, "bitwise operands must be int");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_binop(p->cg, KIT_CG_INT_XOR, 0);
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_bor(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_bxor(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_PIPE) {
     if (p->tail_call_expr) break;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_BIT_OR))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     KitCgTypeId ty2 = toy_parse_expr_bxor(p);
     if (ty2 == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (!toy_type_is_promotable_int(p, ty) ||
         !toy_type_is_promotable_int(p, ty2) ||
         !toy_promote_binary_int_operands(p, &ty, &ty2)) {
       toy_error(p, p->cur.loc, "bitwise operands must be int");
       return KIT_CG_TYPE_NONE;
     }
     kit_cg_int_binop(p->cg, KIT_CG_INT_OR, 0);
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_and(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_bor(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_AND) {
     if (p->tail_call_expr) break;
     KitCgTypeId bool_ty = toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
     KitCgLabel false_label;
     KitCgLabel end_label;
     KitCgLocal result_slot;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_LOGIC_AND))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     false_label = kit_cg_label_new(p->cg);
     end_label = kit_cg_label_new(p->cg);
     result_slot = kit_cg_local(p->cg, bool_ty, toy_slot_attrs(0));
     if (!toy_emit_truthy(p, ty)) return KIT_CG_TYPE_NONE;
     kit_cg_branch_false(p->cg, false_label);
     ty = toy_parse_expr_bor(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (!toy_emit_truthy(p, ty)) return KIT_CG_TYPE_NONE;
     kit_cg_branch_false(p->cg, false_label);
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_push_int(p->cg, 1, bool_ty);
     kit_cg_store(p->cg, toy_mem_access(p, bool_ty));
     kit_cg_jump(p->cg, end_label);
     kit_cg_label_place(p->cg, false_label);
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_push_int(p->cg, 0, bool_ty);
     kit_cg_store(p->cg, toy_mem_access(p, bool_ty));
     kit_cg_label_place(p->cg, end_label);
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_load(p->cg, toy_mem_access(p, bool_ty));
     ty = bool_ty;
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 static KitCgTypeId toy_parse_expr_or(ToyParser* p) {
   KitCgTypeId ty = toy_parse_expr_and(p);
   if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
   while (p->cur.kind == TOK_OR) {
     if (p->tail_call_expr) break;
     KitCgTypeId bool_ty = toy_builtin_type(p, KIT_CG_BUILTIN_BOOL);
     KitCgLabel true_label;
     KitCgLabel end_label;
     KitCgLocal result_slot;
     if (!toy_note_expr_island(p, TOY_EXPR_ISLAND_LOGIC_OR))
       return KIT_CG_TYPE_NONE;
     toy_parser_advance(p);
     true_label = kit_cg_label_new(p->cg);
     end_label = kit_cg_label_new(p->cg);
     result_slot = kit_cg_local(p->cg, bool_ty, toy_slot_attrs(0));
     if (!toy_emit_truthy(p, ty)) return KIT_CG_TYPE_NONE;
     kit_cg_branch_true(p->cg, true_label);
     ty = toy_parse_expr_and(p);
     if (ty == KIT_CG_TYPE_NONE) return KIT_CG_TYPE_NONE;
     if (toy_reject_tail_call_operand(p)) return KIT_CG_TYPE_NONE;
     if (!toy_emit_truthy(p, ty)) return KIT_CG_TYPE_NONE;
     kit_cg_branch_true(p->cg, true_label);
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_push_int(p->cg, 0, bool_ty);
     kit_cg_store(p->cg, toy_mem_access(p, bool_ty));
     kit_cg_jump(p->cg, end_label);
     kit_cg_label_place(p->cg, true_label);
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_push_int(p->cg, 1, bool_ty);
     kit_cg_store(p->cg, toy_mem_access(p, bool_ty));
     kit_cg_label_place(p->cg, end_label);
     kit_cg_push_local(p->cg, result_slot);
     kit_cg_load(p->cg, toy_mem_access(p, bool_ty));
     ty = bool_ty;
     toy_note_cg_result_type(p, ty);
   }
   return ty;
 }
 
 KitCgTypeId toy_parse_expr(ToyParser* p) {
   uint32_t saved_island_mask = p->expr_island_mask;
   KitCgTypeId ty;
   p->expr_island_mask = 0;
   ty = toy_parse_expr_or(p);
   if (ty != KIT_CG_TYPE_NONE &&
       (p->cur.kind == TOK_ANDAND || p->cur.kind == TOK_PIPEPIPE)) {
     toy_error(p, p->cur.loc,
               "legacy logical operator is unsupported; use 'and' or 'or'");
     ty = KIT_CG_TYPE_NONE;
   }
   p->expr_island_mask = saved_island_mask;
   return ty;
 }