#include "silver/ast.h"
#include "silver/compile_ctx.h"
#include "silver/engine.h"
#include "silver/compiler.h"
#include "silver/directives.h"

#include "internal.h"
#include "debug.h"
#include "tokens.h"
#include "runtime.h"
#include "ops/coercion.h"

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

enum {
  SV_ITER_HINT_GENERIC = 0,
  SV_ITER_HINT_ARRAY = 1,
  SV_ITER_HINT_STRING = 4,
};

static const char *pin_source_text(const char *source, ant_offset_t source_len) {
  if (!source || source_len <= 0) return source;
  const char *pinned = code_arena_alloc(source, (size_t)source_len);
  return pinned ? pinned : source;
}

static void emit(sv_compiler_t *c, uint8_t byte) {
  if (c->code_len >= c->code_cap) {
    c->code_cap = c->code_cap ? c->code_cap * 2 : 256;
    c->code = realloc(c->code, (size_t)c->code_cap);
  }
  c->code[c->code_len++] = byte;
}

static void emit_u16(sv_compiler_t *c, uint16_t val) {
  emit(c, (uint8_t)(val & 0xFF));
  emit(c, (uint8_t)(val >> 8));
}

static void emit_u32(sv_compiler_t *c, uint32_t val) {
  emit(c, (uint8_t)(val & 0xFF));
  emit(c, (uint8_t)((val >> 8) & 0xFF));
  emit(c, (uint8_t)((val >> 16) & 0xFF));
  emit(c, (uint8_t)((val >> 24) & 0xFF));
}

static void emit_i32(sv_compiler_t *c, int32_t val) {
  uint32_t u;
  memcpy(&u, &val, 4);
  emit_u32(c, u);
}

static void emit_op(sv_compiler_t *c, sv_op_t op) {
  emit(c, (uint8_t)op);
}

static void compile_receiver_property_get(sv_compiler_t *c, sv_ast_t *node);
static void compile_truthy_test_expr(sv_compiler_t *c, sv_ast_t *node);

static void emit_srcpos(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) return;
  const char *code = c->source;
  ant_offset_t clen = c->source_len;
  if (!code || clen <= 0) return;

  uint32_t off = node->src_off;
  if (off > clen) off = (uint32_t)clen;
  uint32_t end = node->src_end;
  if (end > clen) end = (uint32_t)clen;
  if (end < off) end = off;
  if (end == off && off < (uint32_t)clen) end = off + 1;
  if (end == off) return;

  if (c->srcpos_count > 0 && c->last_srcpos_off == off && c->last_srcpos_end == end) return;

  uint32_t line, col;
  if (c->line_table) sv_compile_ctx_line_table_lookup(c->line_table, off, &line, &col);
  else if (c->srcpos_count > 0 && off >= c->last_srcpos_off) {
    line = c->srcpos[c->srcpos_count - 1].line;
    col = c->srcpos[c->srcpos_count - 1].col;
    for (uint32_t i = c->last_srcpos_off; i < off; i++) {
      if (code[i] == '\n') { line++; col = 1; }
      else col++;
    }
  } else {
    line = 1; col = 1;
    for (uint32_t i = 0; i < off; i++) {
      if (code[i] == '\n') { line++; col = 1; }
      else col++;
    }
  }

  if (c->srcpos_count >= c->srcpos_cap) {
    c->srcpos_cap = c->srcpos_cap ? c->srcpos_cap * 2 : 32;
    c->srcpos = realloc(c->srcpos, (size_t)c->srcpos_cap * sizeof(sv_srcpos_t));
  }
  c->srcpos[c->srcpos_count++] = (sv_srcpos_t){
    .bc_offset = (uint32_t)c->code_len,
    .line = line,
    .col = col,
    .src_off = off,
    .src_end = end,
  };
  c->last_srcpos_off = off;
  c->last_srcpos_end = end;
}

static void patch_u32(sv_compiler_t *c, int offset, uint32_t val) {
  c->code[offset]     = (uint8_t)(val & 0xFF);
  c->code[offset + 1] = (uint8_t)((val >> 8) & 0xFF);
  c->code[offset + 2] = (uint8_t)((val >> 16) & 0xFF);
  c->code[offset + 3] = (uint8_t)((val >> 24) & 0xFF);
}

static int add_constant(sv_compiler_t *c, ant_value_t val) {
  if (vtype(val) == T_STR) {
    ant_offset_t slen;
    ant_offset_t off = vstr(c->js, val, &slen);
    const char *sptr = (const char *)(uintptr_t)off;

    const_dedup_entry_t *found = NULL;
    HASH_FIND(hh, c->const_dedup, sptr, (size_t)slen, found);
    if (found) return found->index;

    int idx = c->const_count;
    if (c->const_count >= c->const_cap) {
      c->const_cap = c->const_cap ? c->const_cap * 2 : 16;
      c->constants = realloc(c->constants, (size_t)c->const_cap * sizeof(ant_value_t));
    }
    c->constants[c->const_count++] = val;

    const_dedup_entry_t *entry = malloc(sizeof(const_dedup_entry_t));
    if (entry) {
      entry->str = sptr;
      entry->len = (size_t)slen;
      entry->index = idx;
      HASH_ADD_KEYPTR(hh, c->const_dedup, entry->str, entry->len, entry);
    }
    return idx;
  }

  if (c->const_count >= c->const_cap) {
    c->const_cap = c->const_cap ? c->const_cap * 2 : 16;
    c->constants = realloc(c->constants, (size_t)c->const_cap * sizeof(ant_value_t));
  }
  c->constants[c->const_count] = val;
  return c->const_count++;
}

static void build_gc_const_tables(sv_func_t *func) {
  if (!func || func->const_count <= 0 || !func->constants) return;

  int child_count = 0;
  for (int i = 0; i < func->const_count; i++) {
    if (vtype(func->constants[i]) == T_NTARG) child_count++;
  }

  if (child_count > 0) {
    func->child_funcs = code_arena_bump((size_t)child_count * sizeof(sv_func_t *));
    if (func->child_funcs) {
      int out = 0;
      for (int i = 0; i < func->const_count; i++) {
        if (vtype(func->constants[i]) != T_NTARG) continue;
        func->child_funcs[out++] = (sv_func_t *)(uintptr_t)vdata(func->constants[i]);
      } func->child_func_count = child_count;
    }
  }

  uint8_t *marked_slots = calloc((size_t)func->const_count, sizeof(uint8_t));
  if (!marked_slots) return;

  int slot_count = 0;
  for (int pc = 0; pc < func->code_len;) {
    sv_op_t op = (sv_op_t)func->code[pc];
    int size = (op < OP__COUNT) ? sv_op_size[op] : 0;
    if (size <= 0) break;

    if (op == OP_PUT_CONST) {
      uint32_t idx = sv_get_u32(func->code + pc + 1);
      if (idx < (uint32_t)func->const_count && !marked_slots[idx]) {
        marked_slots[idx] = 1; slot_count++;
      }
    }

    pc += size;
  }

  if (slot_count > 0) {
    func->gc_const_slots = code_arena_bump((size_t)slot_count * sizeof(uint32_t));
    if (func->gc_const_slots) {
      int out = 0;
      for (int i = 0; i < func->const_count; i++) {
        if (!marked_slots[i]) continue;
        func->gc_const_slots[out++] = (uint32_t)i;
      }
      func->gc_const_slot_count = slot_count;
    }
  }

  free(marked_slots);
}

static void emit_constant(sv_compiler_t *c, ant_value_t val) {
  int idx = add_constant(c, val);
  if (idx <= 255) {
    emit_op(c, OP_CONST8);
    emit(c, (uint8_t)idx);
  } else {
    emit_op(c, OP_CONST);
    emit_u32(c, (uint32_t)idx);
  }
}

static void emit_number(sv_compiler_t *c, double num) {
  if (num >= -128 && num <= 127 && num == (int)num && num != -0.0) {
    emit_op(c, OP_CONST_I8);
    emit(c, (uint8_t)(int8_t)num);
  } else emit_constant(c, tov(num));
}


static inline bool is_quoted_ident_key(const sv_ast_t *node) {
  if (!node || node->type != N_IDENT || !node->str || node->len < 2) return false;
  char open = node->str[0];
  char close = node->str[node->len - 1];
  return ((open == '\'' && close == '\'') || (open == '"' && close == '"'));
}

static inline bool is_template_segment(const sv_ast_t *node) {
  return node && node->type == N_STRING && (node->flags & FN_TEMPLATE_SEGMENT);
}

static inline bool is_invalid_cooked_string(const sv_ast_t *node) {
  return is_template_segment(node) && (node->flags & FN_INVALID_COOKED);
}

static inline ant_value_t ast_string_const(sv_compiler_t *c, const sv_ast_t *node) {
  if (!node || !node->str) return js_mkstr_permanent(c->js, "", 0);
  return js_mkstr_permanent(c->js, node->str, node->len);
}

static inline void compile_static_property_key(sv_compiler_t *c, sv_ast_t *key) {
  if (!key) {
    emit_op(c, OP_UNDEF);
    return;
  }

  if (key->type == N_STRING) {
    emit_constant(c, ast_string_const(c, key));
    return;
  }

  if (key->type == N_NUMBER) {
    char buf[32];
    int n = snprintf(buf, sizeof(buf), "%g", key->num);
    emit_constant(c, js_mkstr_permanent(c->js, buf, (size_t)n));
    return;
  }

  if (key->type == N_IDENT) {
    if (is_quoted_ident_key(key))
      emit_constant(c, js_mkstr_permanent(c->js, key->str + 1, key->len - 2));
    else
      emit_constant(c, js_mkstr_permanent(c->js, key->str, key->len));
    return;
  }

  compile_expr(c, key);
}

static int add_atom(sv_compiler_t *c, const char *str, uint32_t len) {
  const char *interned = intern_string(str, (size_t)len);
  const char *stored = interned;
  if (!stored) {
    char *copy = code_arena_bump(len);
    memcpy(copy, str, len);
    stored = copy;
  }

  for (int i = 0; i < c->atom_count; i++) {
    if (c->atoms[i].len == len && c->atoms[i].str == stored)
      return i;
  }
  if (c->atom_count >= c->atom_cap) {
    c->atom_cap = c->atom_cap ? c->atom_cap * 2 : 16;
    c->atoms = realloc(c->atoms, (size_t)c->atom_cap * sizeof(sv_atom_t));
  }
  c->atoms[c->atom_count] = (sv_atom_t){ .str = stored, .len = len };
  return c->atom_count++;
}

static inline bool sv_op_has_ic_slot(sv_op_t op) {
  return op == OP_GET_GLOBAL || op == OP_GET_GLOBAL_UNDEF ||
         op == OP_GET_FIELD || op == OP_GET_FIELD2 || op == OP_PUT_FIELD;
}

static uint16_t alloc_ic_idx(sv_compiler_t *c) {
  if (!c || c->ic_count >= (int)UINT16_MAX) return UINT16_MAX;
  return (uint16_t)c->ic_count++;
}

static void sv_func_init_obj_sites(sv_func_t *func) {
  if (!func || !func->code || func->code_len <= 0) return;

  uint32_t count = 0;
  for (int pc = 0; pc < func->code_len; ) {
    sv_op_t op = (sv_op_t)func->code[pc];
    if (op == OP_OBJECT) count++;
    uint8_t size = (op < OP__COUNT) ? sv_op_size[op] : 1;
    pc += (size > 0) ? size : 1;
  }
  if (count == 0) return;

  func->obj_sites = code_arena_bump((size_t)count * sizeof(sv_obj_site_cache_t));
  memset(func->obj_sites, 0, (size_t)count * sizeof(sv_obj_site_cache_t));
  func->obj_site_count = (uint16_t)count;

  uint32_t idx = 0;
  for (int pc = 0; pc < func->code_len && idx < count; ) {
    sv_op_t op = (sv_op_t)func->code[pc];
    if (op == OP_OBJECT) func->obj_sites[idx++].bc_off = (uint32_t)pc;
    uint8_t size = (op < OP__COUNT) ? sv_op_size[op] : 1;
    pc += (size > 0) ? size : 1;
  }
}

static void emit_atom_idx_op(sv_compiler_t *c, sv_op_t op, uint32_t atom_idx) {
  emit_op(c, op);
  emit_u32(c, atom_idx);
  if (sv_op_has_ic_slot(op))
    emit_u16(c, alloc_ic_idx(c));
}

static void emit_atom_op(sv_compiler_t *c, sv_op_t op, const char *str, uint32_t len) {
  int idx = add_atom(c, str, len);
  emit_atom_idx_op(c, op, (uint32_t)idx);
}

static inline void emit_set_function_name(
  sv_compiler_t *c,
  const char *name, uint32_t len
) {
  if (!name) { name = ""; len = 0; }
  emit_atom_op(c, OP_SET_NAME, name, len);
}

static void emit_const_assign_error(sv_compiler_t *c, const char *name, uint32_t len) {
  static const char prefix[] = "Assignment to constant variable '";
  static const char suffix[] = "'";
  
  uint32_t mlen = (uint32_t)(sizeof(prefix) - 1 + len + sizeof(suffix) - 1);
  char *buf = code_arena_bump(mlen);
  
  memcpy(buf, prefix, sizeof(prefix) - 1);
  memcpy(buf + sizeof(prefix) - 1, name, len);
  memcpy(buf + sizeof(prefix) - 1 + len, suffix, sizeof(suffix) - 1);
  
  int atom = add_atom(c, buf, mlen);
  emit_op(c, OP_THROW_ERROR);
  emit_u32(c, (uint32_t)atom);
  emit(c, (uint8_t)JS_ERR_TYPE);
}

static inline bool is_ident_str(
  const char *name, uint32_t len,
  const char *lit, uint32_t lit_len
) {
  return len == lit_len && memcmp(name, lit, lit_len) == 0;
}

static inline bool is_strict_restricted_ident(const char *name, uint32_t len) {
  return 
    is_ident_str(name, len, "eval", 4) ||
    is_ident_str(name, len, "arguments", 9);
}

static inline bool is_repl_top_level(const sv_compiler_t *c) {
  return 
    c->mode == SV_COMPILE_REPL && c->scope_depth == 0 &&
    c->enclosing && !c->enclosing->enclosing &&
    !c->is_strict;
}

static inline bool has_completion_value(const sv_compiler_t *c) {
  return c && (c->mode == SV_COMPILE_EVAL || c->mode == SV_COMPILE_REPL);
}

static inline bool has_module_import_binding(const sv_compiler_t *c) {
  for (const sv_compiler_t *cur = c; cur; cur = cur->enclosing) {
    if (cur->mode == SV_COMPILE_MODULE) return true;
  }
  return false;
}

static inline bool has_implicit_arguments_obj(const sv_compiler_t *c) {
  return c && !c->is_arrow && c->enclosing;
}

static int resolve_local(sv_compiler_t *c, const char *name, uint32_t len) {
  if (c->local_lookup_heads && c->local_lookup_cap > 0) {
    uint32_t hash = sv_compile_ctx_hash_local_name(name, len);
    int bucket = (int)(hash & (uint32_t)(c->local_lookup_cap - 1));
    for (int i = c->local_lookup_heads[bucket]; i != -1; i = c->locals[i].lookup_next) {
      sv_local_t *loc = &c->locals[i];
      if (
        loc->name_hash == hash &&
        loc->name_len == len &&
        memcmp(loc->name, name, len) == 0
      ) return i;
    }
    return -1;
  }

  for (int i = c->local_count - 1; i >= 0; i--) {
    sv_local_t *loc = &c->locals[i];
    if (loc->name_len == len && memcmp(loc->name, name, len) == 0) return i;
  }
  
  return -1;
}

static int add_local(
  sv_compiler_t *c, const char *name, uint32_t len,
  bool is_const, int depth
) {
  sv_compile_ctx_ensure_local_lookup_capacity(c, c->local_count + 1);
  if (c->local_count >= c->local_cap) {
    c->local_cap = c->local_cap ? c->local_cap * 2 : 16;
    c->locals = realloc(c->locals, (size_t)c->local_cap * sizeof(sv_local_t));
  }
  int idx = c->local_count++;
  if (c->local_count > c->max_local_count)
    c->max_local_count = c->local_count;
  c->locals[idx] = (sv_local_t){
    .name = name, .name_len = len,
    .name_hash = sv_compile_ctx_hash_local_name(name, len),
    .lookup_next = -1,
    .depth = depth, .is_const = is_const, .captured = false,
    .inferred_type = SV_TI_UNKNOWN,
  };
  sv_compile_ctx_local_lookup_insert(c, idx);
  return idx;
}

static int reserve_hidden_locals(sv_compiler_t *c, int count) {
  int base = c->local_count;
  for (int i = 0; i < count; i++)
    add_local(c, "", 0, false, c->scope_depth);
  return base;
}

static inline bool sv_type_is_known(uint8_t t) {
  return t != SV_TI_UNKNOWN;
}

static inline bool sv_type_is_num(uint8_t t) {
  return t == SV_TI_NUM;
}

static void ensure_slot_type_cap(sv_compiler_t *c, int slot) {
  if (slot < 0) return;
  if (slot < c->slot_type_cap) return;
  int new_cap = c->slot_type_cap ? c->slot_type_cap : 16;
  while (new_cap <= slot) new_cap *= 2;
  sv_type_info_t *next = realloc(c->slot_types, (size_t)new_cap * sizeof(sv_type_info_t));
  if (!next) return;
  memset(next + c->slot_type_cap, 0, (size_t)(new_cap - c->slot_type_cap) * sizeof(sv_type_info_t));
  c->slot_types = next;
  c->slot_type_cap = new_cap;
}

static void mark_slot_type(sv_compiler_t *c, int slot, uint8_t type) {
  if (slot < 0) return;
  ensure_slot_type_cap(c, slot);
  if (!c->slot_types || slot >= c->slot_type_cap) return;
  uint8_t old = c->slot_types[slot].type;
  if (!sv_type_is_known(type)) {
    c->slot_types[slot].type = SV_TI_UNKNOWN;
    return;
  }
  if (!sv_type_is_known(old))
    c->slot_types[slot].type = type;
  else if (old != type)
    c->slot_types[slot].type = SV_TI_UNKNOWN;
}

static void set_local_inferred_type(sv_compiler_t *c, int local_idx, uint8_t type) {
  if (local_idx < 0 || local_idx >= c->local_count) return;
  c->locals[local_idx].inferred_type = type;
  if (c->locals[local_idx].depth == -1) return;
  int slot = local_idx - c->param_locals;
  mark_slot_type(c, slot, type);
}

static inline uint8_t get_local_inferred_type(sv_compiler_t *c, int local_idx) {
  if (local_idx < 0 || local_idx >= c->local_count) return SV_TI_UNKNOWN;
  if (c->locals[local_idx].depth == -1) return SV_TI_UNKNOWN;
  if (c->locals[local_idx].is_tdz) return SV_TI_UNKNOWN;
  return c->locals[local_idx].inferred_type;
}

static const char *typeof_name_for_type(uint8_t type) {
  switch (type) {
    case SV_TI_NUM:   return "number";
    case SV_TI_STR:   return "string";
    case SV_TI_BOOL:  return "boolean";
    case SV_TI_UNDEF: return "undefined";
    case SV_TI_ARR:
    case SV_TI_OBJ:
    case SV_TI_NULL:  return "object";
    default:          return NULL;
  }
}

static uint8_t iter_hint_for_type(uint8_t type) {
  switch (type) {
    case SV_TI_ARR: return SV_ITER_HINT_ARRAY;
    case SV_TI_STR: return SV_ITER_HINT_STRING;
    default:        return SV_ITER_HINT_GENERIC;
  }
}

static int ensure_local_at_depth(
  sv_compiler_t *c, const char *name, uint32_t len,
  bool is_const, int depth
) {
  int local = resolve_local(c, name, len);
  if (local != -1 && c->locals[local].depth == depth)
    return local;
  return add_local(c, name, len, is_const, depth);
}

static int local_to_frame_slot(sv_compiler_t *c, int local_idx) {
  if (c->locals[local_idx].depth == -1) return local_idx;
  return c->param_count + (local_idx - c->param_locals);
}

static int resolve_local_slot(sv_compiler_t *c, const char *name, uint32_t len) {
  int local = resolve_local(c, name, len);
  if (local == -1 || c->locals[local].depth == -1) return -1;
  int slot = local - c->param_locals;
  return (slot >= 0 && slot <= 255) ? slot : -1;
}

static int add_upvalue(sv_compiler_t *c, uint16_t index, bool is_local, bool is_const) {
  for (int i = 0; i < c->upvalue_count; i++) {
    if (c->upval_descs[i].index == index &&
        c->upval_descs[i].is_local == is_local)
      return i;
  }
  if (c->upvalue_count >= c->upvalue_cap) {
    c->upvalue_cap = c->upvalue_cap ? c->upvalue_cap * 2 : 8;
    c->upval_descs = realloc(
      c->upval_descs,
      (size_t)c->upvalue_cap * sizeof(sv_upval_desc_t));
  }
  int idx = c->upvalue_count++;
  c->upval_descs[idx] = (sv_upval_desc_t){
    .index = index, .is_local = is_local, .is_const = is_const,
  };
  return idx;
}

static int resolve_super_upvalue(sv_compiler_t *c) {
  if (!c->enclosing) return -1;
  sv_compiler_t *enc = c->enclosing;

  if (!enc->is_arrow) {
    if (enc->super_local < 0) return -1;
    enc->locals[enc->super_local].captured = true;
    uint16_t slot = (uint16_t)local_to_frame_slot(enc, enc->super_local);
    return add_upvalue(c, slot, true, false);
  }

  int upvalue = resolve_super_upvalue(enc);
  if (upvalue == -1) return -1;
  return add_upvalue(c, (uint16_t)upvalue, false, false);
}

static int resolve_arguments_upvalue(sv_compiler_t *c) {
  if (!c->enclosing) return -1;
  sv_compiler_t *enc = c->enclosing;

  if (!enc->is_arrow) {
    if (enc->strict_args_local < 0) return -1;
    enc->locals[enc->strict_args_local].captured = true;
    uint16_t slot = (uint16_t)local_to_frame_slot(enc, enc->strict_args_local);
    return add_upvalue(c, slot, true, false);
  }

  int upvalue = resolve_arguments_upvalue(enc);
  if (upvalue == -1) return -1;
  
  return add_upvalue(c, (uint16_t)upvalue, false, false);
}

static int resolve_upvalue(sv_compiler_t *c, const char *name, uint32_t len) {
  if (!c->enclosing) return -1;

  int local = resolve_local(c->enclosing, name, len);
  if (local != -1) {
    c->enclosing->locals[local].captured = true;
    uint16_t slot = (uint16_t)local_to_frame_slot(c->enclosing, local);
    return add_upvalue(c, slot, true, c->enclosing->locals[local].is_const);
  }

  int upvalue = resolve_upvalue(c->enclosing, name, len);
  if (upvalue != -1) {
    bool uv_const = c->enclosing->upval_descs[upvalue].is_const;
    return add_upvalue(c, (uint16_t)upvalue, false, uv_const);
  }

  return -1;
}

static int emit_jump(sv_compiler_t *c, sv_op_t op) {
  emit_op(c, op);
  int offset = c->code_len;
  emit_i32(c, 0);
  return offset;
}

static void patch_jump(sv_compiler_t *c, int offset) {
  int32_t delta = (int32_t)(c->code_len - offset - 4);
  patch_u32(c, offset, (uint32_t)delta);
}

static void emit_loop(sv_compiler_t *c, int loop_start) {
  emit_op(c, OP_JMP);
  int32_t delta = (int32_t)(loop_start - c->code_len - 4);
  emit_i32(c, delta);
}

static void patch_list_add(sv_patch_list_t *pl, int offset) {
  if (pl->count >= pl->cap) {
    pl->cap = pl->cap ? pl->cap * 2 : 4;
    pl->offsets = realloc(pl->offsets, (size_t)pl->cap * sizeof(int));
  }
  pl->offsets[pl->count++] = offset;
}

static void patch_list_resolve(sv_compiler_t *c, sv_patch_list_t *pl) {
  for (int i = 0; i < pl->count; i++)
    patch_jump(c, pl->offsets[i]);
  free(pl->offsets);
  *pl = (sv_patch_list_t){0};
}

static void push_loop(
  sv_compiler_t *c, int loop_start,
  const char *label, uint32_t label_len,
  bool is_switch
) {
  if (c->loop_count >= c->loop_cap) {
    c->loop_cap = c->loop_cap ? c->loop_cap * 2 : 4;
    c->loops = realloc(c->loops, (size_t)c->loop_cap * sizeof(sv_loop_t));
  }
  if (!label && c->pending_label) {
    label = c->pending_label;
    label_len = c->pending_label_len;
    c->pending_label = NULL;
    c->pending_label_len = 0;
  }
  c->loops[c->loop_count++] = (sv_loop_t){
    .loop_start = loop_start,
    .scope_depth = c->scope_depth,
    .label = label, .label_len = label_len,
    .is_switch = is_switch,
  };
}

static void pop_loop(sv_compiler_t *c) {
  sv_loop_t *loop = &c->loops[--c->loop_count];
  patch_list_resolve(c, &loop->breaks);
  free(loop->continues.offsets);
}

static void begin_scope(sv_compiler_t *c) {
  c->scope_depth++;
}

static void end_scope(sv_compiler_t *c) {
  while (
    c->local_count > 0 &&
    c->locals[c->local_count - 1].depth >= c->scope_depth
  ) {
    sv_local_t *loc = &c->locals[c->local_count - 1];
    if (loc->captured) {
      int frame_slot = local_to_frame_slot(c, c->local_count - 1);
      emit_op(c, OP_CLOSE_UPVAL);
      emit_u16(c, (uint16_t)frame_slot);
    }
    sv_compile_ctx_local_lookup_remove(c, c->local_count - 1);
    c->local_count--;
  }
  c->scope_depth--;
}

static void emit_close_upvals(sv_compiler_t *c) {
  for (int i = 0; i < c->local_count; i++) {
  if (c->locals[i].captured) {
    int frame_slot = local_to_frame_slot(c, i);
    emit_op(c, OP_CLOSE_UPVAL);
    emit_u16(c, (uint16_t)frame_slot);
    return;
  }}
}

static void emit_with_get(
  sv_compiler_t *c, const char *name, uint32_t len,
  uint8_t fb_kind, uint16_t fb_idx
) {
  int atom = add_atom(c, name, len);
  emit_op(c, OP_WITH_GET_VAR);
  emit_u32(c, (uint32_t)atom);
  emit(c, fb_kind);
  emit_u16(c, fb_idx);
}

static void emit_with_put(
  sv_compiler_t *c, const char *name, uint32_t len,
  uint8_t fb_kind, uint16_t fb_idx
) {
  int atom = add_atom(c, name, len);
  emit_op(c, OP_WITH_PUT_VAR);
  emit_u32(c, (uint32_t)atom);
  emit(c, fb_kind);
  emit_u16(c, fb_idx);
}

static void emit_get_local(sv_compiler_t *c, int local_idx);
static void emit_put_local(sv_compiler_t *c, int local_idx);
static void emit_put_local_typed(sv_compiler_t *c, int local_idx, uint8_t type);

static inline void emit_get_module_import_binding(sv_compiler_t *c) {
  emit_op(c, OP_SPECIAL_OBJ);
  emit(c, 3);
}

static void emit_get_var(sv_compiler_t *c, const char *name, uint32_t len) {
  bool is_super = is_ident_str(name, len, "super", 5);

  if (is_super && c->super_local >= 0) {
    emit_get_local(c, c->super_local);
    return;
  }
  
  if (is_super && c->is_arrow) {
  int super_upval = resolve_super_upvalue(c);
  if (super_upval != -1) {
    emit_op(c, OP_GET_UPVAL);
    emit_u16(c, (uint16_t)super_upval);
    return;
  }}

  int local = resolve_local(c, name, len);
  if (local != -1) {
    if (c->with_depth > 0) {
      uint8_t kind = c->locals[local].depth == -1 ? WITH_FB_ARG : WITH_FB_LOCAL;
      uint16_t idx = kind == WITH_FB_ARG 
        ? (uint16_t)local
        : (uint16_t)(local - c->param_locals);
      emit_with_get(c, name, len, kind, idx);
      return;
    }
    if (c->locals[local].depth == -1) {
      emit_op(c, OP_GET_ARG);
      emit_u16(c, (uint16_t)local);
    } else {
      int slot = local - c->param_locals;
      if (c->locals[local].is_tdz) {
        int ai = add_atom(c, name, len);
        emit_op(c, OP_GET_LOCAL_CHK);
        emit_u16(c, (uint16_t)slot);
        emit_u32(c, (uint32_t)ai);
      } else if (slot <= 255) {
        emit_op(c, OP_GET_LOCAL8);
        emit(c, (uint8_t)slot);
      } else {
        emit_op(c, OP_GET_LOCAL);
        emit_u16(c, (uint16_t)slot);
      }
    }
    return;
  }
  
  int upval = resolve_upvalue(c, name, len);
  if (upval != -1) {
    if (c->with_depth > 0) {
      emit_with_get(c, name, len, WITH_FB_UPVAL, (uint16_t)upval);
      return;
    }
    emit_op(c, OP_GET_UPVAL);
    emit_u16(c, (uint16_t)upval);
    return;
  }
  
  if (is_ident_str(name, len, "arguments", 9)) {
    if (has_implicit_arguments_obj(c)) {
      if (c->strict_args_local >= 0) {
        emit_get_local(c, c->strict_args_local);
      } else {
        emit_op(c, OP_SPECIAL_OBJ);
        emit(c, 0);
      }
      return;
    }
    if (c->is_arrow) {
      int args_upval = resolve_arguments_upvalue(c);
      if (args_upval != -1) {
        emit_op(c, OP_GET_UPVAL);
        emit_u16(c, (uint16_t)args_upval);
        return;
      }
    }
  }
  
  if (has_module_import_binding(c) && is_ident_str(name, len, "import", 6)) {
    emit_get_module_import_binding(c);
    return;
  }
  
  if (c->with_depth > 0) emit_with_get(c, name, len, WITH_FB_GLOBAL, 0);
  else emit_atom_op(c, OP_GET_GLOBAL, name, len);
}

static void emit_set_var(sv_compiler_t *c, const char *name, uint32_t len, bool keep) {
  int local = resolve_local(c, name, len);
  if (local != -1) {
    if (c->locals[local].is_const) {
      emit_const_assign_error(c, name, len);
      return;
    }
    set_local_inferred_type(c, local, SV_TI_UNKNOWN);

    if (c->with_depth > 0) {
      uint8_t kind = c->locals[local].depth == -1 ? WITH_FB_ARG : WITH_FB_LOCAL;
      uint16_t idx = kind == WITH_FB_ARG 
        ? (uint16_t)local
        : (uint16_t)(local - c->param_locals);
      if (keep) emit_op(c, OP_DUP);
      emit_with_put(c, name, len, kind, idx);
      return;
    }
    if (c->locals[local].depth == -1) {
      emit_op(c, keep ? OP_SET_ARG : OP_PUT_ARG);
      emit_u16(c, (uint16_t)local);
    } else {
      int slot = local - c->param_locals;
      sv_op_t op = keep 
        ? (slot <= 255 ? OP_SET_LOCAL8 : OP_SET_LOCAL)
        : (slot <= 255 ? OP_PUT_LOCAL8 : OP_PUT_LOCAL);
      emit_op(c, op);
      if (slot <= 255) emit(c, (uint8_t)slot);
      else emit_u16(c, (uint16_t)slot);
    }
    return;
  }
  int upval = resolve_upvalue(c, name, len);
  if (upval != -1) {
    if (c->upval_descs[upval].is_const) {
      emit_const_assign_error(c, name, len);
      return;
    }
    if (c->with_depth > 0) {
      if (keep) emit_op(c, OP_DUP);
      emit_with_put(c, name, len, WITH_FB_UPVAL, (uint16_t)upval);
      return;
    }
    emit_op(c, keep ? OP_SET_UPVAL : OP_PUT_UPVAL);
    emit_u16(c, (uint16_t)upval);
    return;
  }
  if (has_module_import_binding(c) && is_ident_str(name, len, "import", 6)) {
    emit_const_assign_error(c, name, len);
    return;
  }
  if (c->with_depth > 0) {
    if (keep) emit_op(c, OP_DUP);
    emit_with_put(c, name, len, WITH_FB_GLOBAL, 0);
  } else {
    if (keep) {
      emit_op(c, OP_DUP);
      emit_atom_op(c, OP_PUT_GLOBAL, name, len);
    } else emit_atom_op(c, OP_PUT_GLOBAL, name, len);
  }
}

static void emit_put_local_typed(sv_compiler_t *c, int local_idx, uint8_t type) {
  int slot = local_idx - c->param_locals;
  if (slot <= 255) { emit_op(c, OP_PUT_LOCAL8); emit(c, (uint8_t)slot); }
  else { emit_op(c, OP_PUT_LOCAL); emit_u16(c, (uint16_t)slot); }
  set_local_inferred_type(c, local_idx, type);
}

static inline void emit_slot_op(sv_compiler_t *c, sv_op_t op, uint16_t slot) {
  emit_op(c, op);
  emit_u16(c, slot);
}

static void emit_put_local(sv_compiler_t *c, int local_idx) {
  emit_put_local_typed(c, local_idx, SV_TI_UNKNOWN);
}

static uint8_t infer_expr_type(sv_compiler_t *c, sv_ast_t *node);

static void emit_get_local(sv_compiler_t *c, int local_idx) {
  int slot = local_idx - c->param_locals;
  if (slot <= 255) { emit_op(c, OP_GET_LOCAL8); emit(c, (uint8_t)slot); }
  else { emit_op(c, OP_GET_LOCAL); emit_u16(c, (uint16_t)slot); }
}

static bool match_self_append_local(
  sv_compiler_t *c, sv_ast_t *node,
  int *out_local_idx, uint16_t *out_slot, sv_ast_t **out_rhs
) {
  if (!c || !node || node->type != N_ASSIGN || !node->left || node->left->type != N_IDENT)
    return false;
  if (c->with_depth > 0) return false;

  int local = resolve_local(c, node->left->str, node->left->len);
  if (local < 0 || c->locals[local].is_const) return false;
  if (c->locals[local].is_tdz) return false;
  if (c->locals[local].depth == -1 && c->strict_args_local >= 0) return false;

  sv_ast_t *rhs = NULL;
  if (node->op == TOK_PLUS_ASSIGN) rhs = node->right;
  else if (
    node->op == TOK_ASSIGN &&
    node->right && node->right->type == N_BINARY && node->right->op == TOK_PLUS &&
    node->right->left && node->right->left->type == N_IDENT &&
    node->right->left->len == node->left->len &&
    memcmp(node->right->left->str, node->left->str, node->left->len) == 0
  ) rhs = node->right->right;

  if (!rhs) return false;
  uint8_t local_type = get_local_inferred_type(c, local);
  uint8_t rhs_type = infer_expr_type(c, rhs);
  if (local_type != SV_TI_STR && rhs_type != SV_TI_STR)
    return false;
    
  if (out_local_idx) *out_local_idx = local;
  if (out_slot) *out_slot = (uint16_t)local_to_frame_slot(c, local);
  if (out_rhs) *out_rhs = rhs;
  
  return true;
}

static bool is_self_append_inplace_safe_ident(sv_compiler_t *c, sv_ast_t *node) {
  if (!c || !node || node->type != N_IDENT) return false;

  if (resolve_local(c, node->str, node->len) != -1) return true;
  if (resolve_upvalue(c, node->str, node->len) != -1) return true;

  if (is_ident_str(node->str, node->len, "arguments", 9)) {
    if (has_implicit_arguments_obj(c)) return true;
    if (c->is_arrow && resolve_arguments_upvalue(c) != -1) return true;
  }

  if (c->is_arrow && is_ident_str(node->str, node->len, "super", 5))
    return resolve_super_upvalue(c) != -1;

  if (has_module_import_binding(c) && is_ident_str(node->str, node->len, "import", 6))
    return true;

  return false;
}

static bool is_self_append_inplace_safe_expr(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) return false;

  switch (node->type) {
    case N_NUMBER:
    case N_STRING:
    case N_BIGINT:
    case N_BOOL:
    case N_NULL:
    case N_UNDEF:
      return true;

    case N_IDENT:
      return is_self_append_inplace_safe_ident(c, node);

    case N_BINARY: return 
      is_self_append_inplace_safe_expr(c, node->left) &&
      is_self_append_inplace_safe_expr(c, node->right);
      
    case N_UNARY:
    case N_TYPEOF:
    case N_VOID:
      return is_self_append_inplace_safe_expr(c, node->left);
      
    default:
      return false;
  }
}

static bool compile_self_append_stmt(sv_compiler_t *c, sv_ast_t *node) {
  int local = -1;
  uint16_t slot = 0;
  sv_ast_t *rhs = NULL;
  if (!match_self_append_local(c, node, &local, &slot, &rhs)) return false;
  if (is_self_append_inplace_safe_expr(c, rhs)) {
    compile_expr(c, rhs);
    emit_slot_op(c, OP_STR_APPEND_LOCAL, slot);
  } else {
    emit_slot_op(c, OP_GET_SLOT_RAW, slot);
    compile_expr(c, rhs);
    emit_slot_op(c, OP_STR_ALC_SNAPSHOT, slot);
  }
  set_local_inferred_type(c, local, SV_TI_UNKNOWN);
  return true;
}


static inline bool is_ident_name(sv_ast_t *node, const char *name) {
  size_t n = strlen(name);
  return node 
    && node->type == N_IDENT && node->len == (uint32_t)n 
    && memcmp(node->str, name, n) == 0;
}

static void hoist_var_pattern(sv_compiler_t *c, sv_ast_t *pat) {
  if (!pat) return;
  switch (pat->type) {
    case N_IDENT:
      if (resolve_local(c, pat->str, pat->len) == -1)
        add_local(c, pat->str, pat->len, false, 0);
      break;
    case N_ARRAY: case N_ARRAY_PAT:
      for (int i = 0; i < pat->args.count; i++)
        hoist_var_pattern(c, pat->args.items[i]);
      break;
    case N_OBJECT: case N_OBJECT_PAT:
      for (int i = 0; i < pat->args.count; i++) {
        sv_ast_t *prop = pat->args.items[i];
        if (!prop) continue;
        if (prop->type == N_PROPERTY)
          hoist_var_pattern(c, prop->right);
        else if (prop->type == N_REST || prop->type == N_SPREAD)
          hoist_var_pattern(c, prop->right);
      }
      break;
    case N_ASSIGN_PAT:
      hoist_var_pattern(c, pat->left);
      break;
    case N_ASSIGN:
      hoist_var_pattern(c, pat->left);
      break;
    case N_REST: case N_SPREAD:
      hoist_var_pattern(c, pat->right);
      break;
    default:
      break;
  }
}

static void hoist_var_decls(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) return;
  switch (node->type) {
    case N_VAR:
      if (node->var_kind == SV_VAR_VAR) {
        for (int i = 0; i < node->args.count; i++) {
          sv_ast_t *decl = node->args.items[i];
          if (decl->type == N_VARDECL && decl->left)
            hoist_var_pattern(c, decl->left);
        }
      }
      break;
    case N_BLOCK:
      for (int i = 0; i < node->args.count; i++)
        hoist_var_decls(c, node->args.items[i]);
      break;
    case N_IF:
      hoist_var_decls(c, node->left);
      hoist_var_decls(c, node->right);
      break;
    case N_WHILE: case N_DO_WHILE: case N_LABEL:
      hoist_var_decls(c, node->body);
      break;
    case N_FOR:
      hoist_var_decls(c, node->init);
      hoist_var_decls(c, node->body);
      break;
    case N_FOR_IN: case N_FOR_OF: case N_FOR_AWAIT_OF:
      hoist_var_decls(c, node->left);
      hoist_var_decls(c, node->body);
      break;
    case N_SWITCH:
      for (int i = 0; i < node->args.count; i++) {
        sv_ast_t *cas = node->args.items[i];
        for (int j = 0; j < cas->args.count; j++)
          hoist_var_decls(c, cas->args.items[j]);
      }
      break;
    case N_TRY:
      hoist_var_decls(c, node->body);
      hoist_var_decls(c, node->catch_body);
      hoist_var_decls(c, node->finally_body);
      break;
    case N_EXPORT:
      hoist_var_decls(c, node->left);
      break;
    default: break;
  }
}

static void hoist_lexical_pattern(sv_compiler_t *c, sv_ast_t *pat,
                                  bool is_const) {
  if (!pat) return;

  switch (pat->type) {
    case N_IDENT:
      ensure_local_at_depth(c, pat->str, pat->len, is_const, c->scope_depth);
      break;
    case N_ASSIGN_PAT:
    case N_ASSIGN:
      hoist_lexical_pattern(c, pat->left, is_const);
      break;
    case N_REST:
    case N_SPREAD:
      hoist_lexical_pattern(c, pat->right, is_const);
      break;
    case N_ARRAY:
    case N_ARRAY_PAT:
      for (int i = 0; i < pat->args.count; i++)
        hoist_lexical_pattern(c, pat->args.items[i], is_const);
      break;
    case N_OBJECT:
    case N_OBJECT_PAT:
      for (int i = 0; i < pat->args.count; i++) {
        sv_ast_t *prop = pat->args.items[i];
        if (!prop) continue;
        if (prop->type == N_PROPERTY)
          hoist_lexical_pattern(c, prop->right, is_const);
        else if (prop->type == N_REST || prop->type == N_SPREAD)
          hoist_lexical_pattern(c, prop->right, is_const);
      }
      break;
    default:
      break;
  }
}

static void annex_b_collect_funcs(sv_ast_t *node, sv_ast_list_t *out) {
  if (!node) return;
  if (node->type == N_FUNC && node->str && !(node->flags & FN_ARROW)) {
    sv_ast_list_push(out, node);
    return;
  }
  if (node->type == N_IF) {
    annex_b_collect_funcs(node->left, out);
    annex_b_collect_funcs(node->right, out);
  } else if (node->type == N_LABEL) annex_b_collect_funcs(node->body, out);
}

static void hoist_lexical_decls(sv_compiler_t *c, sv_ast_list_t *stmts) {
  for (int i = 0; i < stmts->count; i++) {
    sv_ast_t *node = stmts->items[i];
    if (!node) continue;
    sv_ast_t *decl_node = (node->type == N_EXPORT) ? node->left : node;
    if (!decl_node) continue;

    if (decl_node->type == N_VAR && decl_node->var_kind != SV_VAR_VAR) {
      bool is_const = 
        (decl_node->var_kind == SV_VAR_CONST ||
        decl_node->var_kind == SV_VAR_USING ||
        decl_node->var_kind == SV_VAR_AWAIT_USING);
      int lb = c->local_count;
      for (int j = 0; j < decl_node->args.count; j++) {
        sv_ast_t *decl = decl_node->args.items[j];
        if (!decl || decl->type != N_VARDECL || !decl->left) continue;
        hoist_lexical_pattern(c, decl->left, is_const);
      }
      for (int j = lb; j < c->local_count; j++) {
        c->locals[j].is_tdz = true;
        set_local_inferred_type(c, j, SV_TI_UNKNOWN);
        int slot = j - c->param_locals;
        emit_op(c, OP_SET_LOCAL_UNDEF);
        emit_u16(c, (uint16_t)slot);
      }
    } else if (decl_node->type == N_IMPORT_DECL) {
      for (int j = 0; j < decl_node->args.count; j++) {
        sv_ast_t *spec = decl_node->args.items[j];
        if (!spec || spec->type != N_IMPORT_SPEC ||
            !spec->right || spec->right->type != N_IDENT)
          continue;
        ensure_local_at_depth(c, spec->right->str, spec->right->len, true, c->scope_depth);
      }
    } else if (decl_node->type == N_CLASS && decl_node->str) {
      int lb = c->local_count;
      ensure_local_at_depth(c, decl_node->str, decl_node->len, false, c->scope_depth);
      if (c->local_count > lb) {
        c->locals[c->local_count - 1].is_tdz = true;
        set_local_inferred_type(c, c->local_count - 1, SV_TI_UNKNOWN);
        int slot = (c->local_count - 1) - c->param_locals;
        emit_op(c, OP_SET_LOCAL_UNDEF);
        emit_u16(c, (uint16_t)slot);
      }
    } else if (decl_node->type == N_FUNC && decl_node->str && !(decl_node->flags & FN_ARROW)) {
      ensure_local_at_depth(c, decl_node->str, decl_node->len, false, c->scope_depth);
    }
    if (!c->is_strict && (decl_node->type == N_IF || decl_node->type == N_LABEL)) {
      sv_ast_list_t funcs = {0};
      annex_b_collect_funcs(decl_node, &funcs);
      for (int j = 0; j < funcs.count; j++) {
        sv_ast_t *fn = funcs.items[j];
        if (resolve_local(c, fn->str, fn->len) == -1)
          add_local(c, fn->str, fn->len, false, c->scope_depth);
      }
    }
  }
}

static void hoist_one_func(sv_compiler_t *c, sv_ast_t *node) {
  sv_func_t *fn = compile_function_body(c, node, c->mode);
  if (!fn) return;
  int idx = add_constant(c, mkval(T_NTARG, (uintptr_t)fn));
  emit_op(c, OP_CLOSURE);
  emit_u32(c, (uint32_t)idx);
  emit_set_function_name(c, node->str, node->len);
  if (is_repl_top_level(c)) {
    emit_atom_op(c, OP_PUT_GLOBAL, node->str, node->len);
  } else {
    int local = resolve_local(c, node->str, node->len);
    emit_put_local(c, local);
  }
}

static void hoist_func_decls(sv_compiler_t *c, sv_ast_list_t *stmts) {
  for (int i = 0; i < stmts->count; i++) {
    sv_ast_t *node = stmts->items[i];
    if (node && node->type == N_EXPORT && node->left)
      node = node->left;
    if (!node) continue;
    if (node->type == N_FUNC && node->str && !(node->flags & FN_ARROW)) {
      hoist_one_func(c, node);
    }
    if (!c->is_strict && (node->type == N_IF || node->type == N_LABEL)) {
      sv_ast_list_t funcs = {0};
      annex_b_collect_funcs(node, &funcs);
      for (int j = 0; j < funcs.count; j++)
        hoist_one_func(c, funcs.items[j]);
    }
  }
}

static uint8_t infer_expr_type(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) return SV_TI_UNDEF;

  switch (node->type) {
    case N_NUMBER:   return SV_TI_NUM;
    case N_STRING:   return SV_TI_STR;
    case N_BOOL:     return SV_TI_BOOL;
    case N_NULL:     return SV_TI_NULL;
    case N_UNDEF:    return SV_TI_UNDEF;
    case N_ARRAY:    return SV_TI_ARR;
    case N_OBJECT:   return SV_TI_OBJ;
    case N_TEMPLATE: return SV_TI_STR;
    case N_TYPEOF:   return SV_TI_STR;
    case N_VOID:     return SV_TI_UNDEF;
    case N_NEW:      return SV_TI_OBJ;

    case N_IDENT: {
      int local = resolve_local(c, node->str, node->len);
      if (local >= 0) return get_local_inferred_type(c, local);
      return SV_TI_UNKNOWN;
    }

    case N_SEQUENCE:
      return infer_expr_type(c, node->right);

    case N_TERNARY: {
      uint8_t lt = infer_expr_type(c, node->left);
      uint8_t rhs_type = infer_expr_type(c, node->right);
      if (lt == rhs_type && sv_type_is_known(lt)) return lt;
      return SV_TI_UNKNOWN;
    }

    case N_UNARY: {
      uint8_t rhs_type = infer_expr_type(c, node->right);
      switch (node->op) {
        case TOK_UPLUS:
        case TOK_UMINUS:
          return sv_type_is_num(rhs_type) ? SV_TI_NUM : SV_TI_UNKNOWN;
        case TOK_NOT:
          return SV_TI_BOOL;
        default:
          return SV_TI_UNKNOWN;
      }
    }

    case N_BINARY: {
      uint8_t lt = infer_expr_type(c, node->left);
      uint8_t rhs_type = infer_expr_type(c, node->right);
      switch (node->op) {
        case TOK_PLUS:
          if (lt == SV_TI_NUM && rhs_type == SV_TI_NUM) return SV_TI_NUM;
          if (lt == SV_TI_STR && rhs_type == SV_TI_STR) return SV_TI_STR;
          return SV_TI_UNKNOWN;
        case TOK_MINUS:
        case TOK_MUL:
        case TOK_DIV:
          return (lt == SV_TI_NUM && rhs_type == SV_TI_NUM) ? SV_TI_NUM : SV_TI_UNKNOWN;
        case TOK_LT:
        case TOK_LE:
        case TOK_GT:
        case TOK_GE:
        case TOK_EQ:
        case TOK_NE:
        case TOK_SEQ:
        case TOK_SNE:
        case TOK_INSTANCEOF:
        case TOK_IN:
          return SV_TI_BOOL;
        case TOK_LAND:
        case TOK_LOR:
        case TOK_NULLISH:
          if (lt == rhs_type && sv_type_is_known(lt)) return lt;
          return SV_TI_UNKNOWN;
        default:
          return SV_TI_UNKNOWN;
      }
    }

    default:
      return SV_TI_UNKNOWN;
  }
}

static void compile_yield_star_expr(sv_compiler_t *c, sv_ast_t *node) {
  if (node->right) compile_expr(c, node->right);
  else emit_op(c, OP_UNDEF);

  int base_local = reserve_hidden_locals(c, 4);
  uint16_t base_slot = (uint16_t)(base_local - c->param_locals);

  emit_op(c, OP_YIELD_STAR_INIT);
  emit_u16(c, base_slot);

  emit_op(c, OP_UNDEF);
  emit_op(c, OP_YIELD_STAR_NEXT);
  emit_u16(c, base_slot);
}

void compile_expr(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) { emit_op(c, OP_UNDEF); return; }
  emit_srcpos(c, node);

  switch (node->type) {
    case N_NUMBER:
      emit_number(c, node->num);
      break;

    case N_STRING: {
      emit_constant(c, ast_string_const(c, node));
      break;
    }

    case N_BIGINT: {
      bool neg = false;
      const char *digits = node->str;
      uint32_t dlen = node->len;
      if (dlen > 0 && digits[0] == '-') {
        neg = true; digits++; dlen--;
      }
      if (dlen > 0 && digits[dlen - 1] == 'n') dlen--;
      ant_value_t bi = js_mkbigint(c->js, digits, dlen, neg);
      emit_constant(c, bi);
      break;
    }

    case N_BOOL:
      emit_op(c, node->num != 0.0 ? OP_TRUE : OP_FALSE);
      break;

    case N_NULL:
      emit_op(c, OP_NULL);
      break;

    case N_UNDEF:
      emit_op(c, OP_UNDEF);
      break;

    case N_THIS:
      emit_op(c, OP_THIS);
      break;

    case N_GLOBAL_THIS:
      emit_op(c, OP_GLOBAL);
      break;

    case N_NEW_TARGET: {
      static const char nt_name[] = "\x01new.target";
      int local = resolve_local(c, nt_name, sizeof(nt_name) - 1);
      if (local >= 0) {
        emit_get_local(c, local);
      } else {
        int upval = resolve_upvalue(c, nt_name, sizeof(nt_name) - 1);
        if (upval >= 0) {
          emit_op(c, OP_GET_UPVAL);
          emit_u16(c, (uint16_t)upval);
        } else {
          emit_op(c, OP_UNDEF);
        }
      }
      break;
    }

    case N_IDENT:
      emit_get_var(c, node->str, node->len);
      break;

    case N_BINARY:
      compile_binary(c, node);
      break;

    case N_UNARY:
      compile_unary(c, node);
      break;

    case N_UPDATE:
      compile_update(c, node);
      break;

    case N_ASSIGN:
      compile_assign(c, node);
      break;

    case N_TERNARY:
      compile_ternary(c, node);
      break;

    case N_CALL:
      compile_call(c, node);
      break;

    case N_NEW:
      compile_new(c, node);
      break;

    case N_MEMBER:
      compile_member(c, node);
      break;

    case N_OPTIONAL:
      compile_optional(c, node);
      break;

    case N_ARRAY:
      compile_array(c, node);
      break;

    case N_OBJECT:
      compile_object(c, node);
      break;

    case N_FUNC:
      compile_func_expr(c, node);
      break;

    case N_CLASS:
      compile_class(c, node);
      break;

    case N_SEQUENCE:
      compile_expr(c, node->left);
      emit_op(c, OP_POP);
      compile_expr(c, node->right);
      break;

    case N_TYPEOF:
      compile_typeof(c, node);
      break;

    case N_VOID:
      compile_expr(c, node->right);
      emit_op(c, OP_VOID);
      break;

    case N_DELETE:
      compile_delete(c, node);
      break;

    case N_SPREAD:
      compile_expr(c, node->right);
      break;

    case N_TEMPLATE:
      compile_template(c, node);
      break;

    case N_AWAIT:
      compile_expr(c, node->right);
      emit_op(c, OP_AWAIT);
      if (c->enclosing && !c->enclosing->enclosing)
        c->is_tla = true;
      break;

    case N_YIELD:
      if (node->flags) compile_yield_star_expr(c, node);
      else {
        if (node->right) compile_expr(c, node->right);
        else emit_op(c, OP_UNDEF);
        emit_op(c, OP_YIELD);
      }
      break;

    case N_THROW:
      compile_expr(c, node->right);
      emit_op(c, OP_THROW);
      break;

    case N_TAGGED_TEMPLATE: {
      compile_expr(c, node->left);
      sv_ast_t *tpl = node->right;
      int n = tpl->args.count;
      int n_strings = 0, n_exprs = 0;
      for (int i = 0; i < n; i++) {
        if (is_template_segment(tpl->args.items[i])) n_strings++;
        else n_exprs++;
      }
      int cache_idx = add_constant(c, js_mkundef());
      emit_op(c, OP_CONST);
      emit_u32(c, (uint32_t)cache_idx);
      int skip_jump = emit_jump(c, OP_JMP_TRUE_PEEK);
      emit_op(c, OP_POP);
      for (int i = 0; i < n; i++) {
        sv_ast_t *item = tpl->args.items[i];
        if (!is_template_segment(item)) continue;
        if (is_invalid_cooked_string(item))
          emit_op(c, OP_UNDEF);
        else emit_constant(c, ast_string_const(c, item));
      }
      emit_op(c, OP_ARRAY);
      emit_u16(c, (uint16_t)n_strings);
      for (int i = 0; i < n; i++) {
        sv_ast_t *item = tpl->args.items[i];
        if (!is_template_segment(item)) continue;
        const char *raw = item->aux ? item->aux : item->str;
        uint32_t raw_len = item->aux ? item->aux_len : item->len;
        emit_constant(c, js_mkstr_permanent(c->js, raw ? raw : "", raw_len));
      }
      emit_op(c, OP_ARRAY);
      emit_u16(c, (uint16_t)n_strings);
      emit_atom_op(c, OP_GET_GLOBAL, "Object", 6);
      emit_atom_op(c, OP_GET_FIELD2, "freeze", 6);
      emit_op(c, OP_ROT3L);
      emit_op(c, OP_CALL_METHOD);
      emit_u16(c, 1);
      emit_atom_op(c, OP_DEFINE_FIELD, "raw", 3);
      emit_atom_op(c, OP_GET_GLOBAL, "Object", 6);
      emit_atom_op(c, OP_GET_FIELD2, "freeze", 6);
      emit_op(c, OP_ROT3L);
      emit_op(c, OP_CALL_METHOD);
      emit_u16(c, 1);
      emit_op(c, OP_DUP);
      emit_op(c, OP_PUT_CONST);
      emit_u32(c, (uint32_t)cache_idx);
      patch_jump(c, skip_jump);
      for (int i = 0; i < n; i++) {
        sv_ast_t *item = tpl->args.items[i];
        if (is_template_segment(item)) continue;
        compile_expr(c, item);
      }
      emit_op(c, OP_CALL);
      emit_u16(c, (uint16_t)(1 + n_exprs));
      break;
    }

    case N_IMPORT:
      compile_expr(c, node->right);
      if (has_module_import_binding(c)) {
        emit_get_module_import_binding(c);
        emit_op(c, OP_SWAP);
        emit_op(c, OP_CALL);
        emit_u16(c, 1);
      } else emit_op(c, OP_IMPORT);
      break;

    case N_REGEXP:
      emit_constant(c, js_mkstr_permanent(c->js, node->str ? node->str : "", node->len));
      emit_constant(c, js_mkstr_permanent(c->js, node->aux ? node->aux : "", node->aux_len));
      emit_op(c, OP_REGEXP);
      break;

    default:
      emit_op(c, OP_UNDEF);
      break;
  }
}

void compile_binary(sv_compiler_t *c, sv_ast_t *node) {
  uint8_t op = node->op;

  if (op == TOK_LAND) {
    compile_expr(c, node->left);
    int jump = emit_jump(c, OP_JMP_FALSE_PEEK);
    emit_op(c, OP_POP);
    compile_expr(c, node->right);
    patch_jump(c, jump);
    return;
  }
  
  if (op == TOK_LOR) {
    compile_expr(c, node->left);
    int jump = emit_jump(c, OP_JMP_TRUE_PEEK);
    emit_op(c, OP_POP);
    compile_expr(c, node->right);
    patch_jump(c, jump);
    return;
  }
  
  if (op == TOK_NULLISH) {
    compile_expr(c, node->left);
    int jump = emit_jump(c, OP_JMP_NOT_NULLISH);
    emit_op(c, OP_POP);
    compile_expr(c, node->right);
    patch_jump(c, jump);
    return;
  }

  if (op == TOK_IN && node->left->type == N_IDENT &&
      node->left->len > 0 && node->left->str[0] == '#') {
    emit_constant(c, js_mkstr_permanent(c->js, node->left->str, node->left->len));
    compile_expr(c, node->right);
    emit_op(c, OP_IN);
    return;
  }

  uint8_t left_type = SV_TI_UNKNOWN;
  uint8_t right_type = SV_TI_UNKNOWN;
  if (op == TOK_PLUS || op == TOK_MINUS || op == TOK_MUL || op == TOK_DIV) {
    left_type = infer_expr_type(c, node->left);
    right_type = infer_expr_type(c, node->right);
  }

  compile_expr(c, node->left);
  compile_expr(c, node->right);

  switch (op) {
    case TOK_PLUS:
      emit_op(c, (left_type == SV_TI_NUM && right_type == SV_TI_NUM) ? OP_ADD_NUM : OP_ADD);
      break;
    case TOK_MINUS:
      emit_op(c, (left_type == SV_TI_NUM && right_type == SV_TI_NUM) ? OP_SUB_NUM : OP_SUB);
      break;
    case TOK_MUL:
      emit_op(c, (left_type == SV_TI_NUM && right_type == SV_TI_NUM) ? OP_MUL_NUM : OP_MUL);
      break;
    case TOK_DIV:
      emit_op(c, (left_type == SV_TI_NUM && right_type == SV_TI_NUM) ? OP_DIV_NUM : OP_DIV);
      break;
    case TOK_REM:        emit_op(c, OP_MOD); break;
    case TOK_EXP:        emit_op(c, OP_EXP); break;
    case TOK_LT:         emit_op(c, OP_LT);  break;
    case TOK_LE:         emit_op(c, OP_LE);  break;
    case TOK_GT:         emit_op(c, OP_GT);  break;
    case TOK_GE:         emit_op(c, OP_GE);  break;
    case TOK_EQ:         emit_op(c, OP_EQ);  break;
    case TOK_NE:         emit_op(c, OP_NE);  break;
    case TOK_SEQ:        emit_op(c, OP_SEQ); break;
    case TOK_SNE:        emit_op(c, OP_SNE); break;
    case TOK_AND:        emit_op(c, OP_BAND); break;
    case TOK_OR:         emit_op(c, OP_BOR);  break;
    case TOK_XOR:        emit_op(c, OP_BXOR); break;
    case TOK_SHL:        emit_op(c, OP_SHL);  break;
    case TOK_SHR:        emit_op(c, OP_SHR);  break;
    case TOK_ZSHR:       emit_op(c, OP_USHR); break;
    case TOK_INSTANCEOF:
      emit_op(c, OP_INSTANCEOF);
      emit_u16(c, alloc_ic_idx(c));
      break;
    case TOK_IN:         emit_op(c, OP_IN);  break;
    default:             emit_op(c, OP_UNDEF); break;
  }
}

void compile_unary(sv_compiler_t *c, sv_ast_t *node) {
  compile_expr(c, node->right);
  switch (node->op) {
    case TOK_NOT:    emit_op(c, OP_NOT);   break;
    case TOK_TILDA:  emit_op(c, OP_BNOT);  break;
    case TOK_UPLUS:  emit_op(c, OP_UPLUS); break;
    case TOK_UMINUS: emit_op(c, OP_NEG);   break;
    default: break;
  }
}


void compile_update(sv_compiler_t *c, sv_ast_t *node) {
  bool prefix = (node->flags & 1);
  bool is_inc = (node->op == TOK_POSTINC);
  sv_ast_t *target = node->right;

  if (target->type == N_IDENT) {
    if (prefix) {
      emit_get_var(c, target->str, target->len);
      emit_op(c, is_inc ? OP_INC : OP_DEC);
      emit_set_var(c, target->str, target->len, true);
    } else {
      emit_get_var(c, target->str, target->len);
      emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
      emit_set_var(c, target->str, target->len, false);
    }
  } else if (target->type == N_MEMBER && !(target->flags & 1)) {
    compile_expr(c, target->left);
    emit_op(c, OP_DUP);
    int atom = add_atom(c, target->right->str, target->right->len);
    emit_atom_idx_op(c, OP_GET_FIELD, (uint32_t)atom);
    if (prefix) {
      emit_op(c, is_inc ? OP_INC : OP_DEC);
      emit_op(c, OP_INSERT2);
      emit_atom_idx_op(c, OP_PUT_FIELD, (uint32_t)atom);
    } else {
      emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
      emit_op(c, OP_SWAP_UNDER);
      emit_atom_idx_op(c, OP_PUT_FIELD, (uint32_t)atom);
    }
  } else if (target->type == N_MEMBER && (target->flags & 1)) {
    compile_expr(c, target->left);
    compile_expr(c, target->right);
    emit_op(c, OP_DUP2);
    emit_op(c, OP_GET_ELEM);
    if (prefix) {
      emit_op(c, is_inc ? OP_INC : OP_DEC);
      emit_op(c, OP_INSERT3);
      emit_op(c, OP_PUT_ELEM);
    } else {
      emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
      emit_op(c, OP_ROT4_UNDER);
      emit_op(c, OP_PUT_ELEM);
    }
  } else {
    emit_op(c, OP_UNDEF);
  }
}

void compile_assign(sv_compiler_t *c, sv_ast_t *node) {
  sv_ast_t *target = node->left;
  uint8_t op = node->op;
  int append_local = -1;
  uint16_t append_slot = 0;
  sv_ast_t *append_rhs = NULL;
  
  bool can_append_builder = match_self_append_local(
    c, node, &append_local, 
    &append_slot, &append_rhs
  );

  if (op == TOK_ASSIGN) {
    if (target->type == N_MEMBER && !(target->flags & 1)) {
      int atom = add_atom(c, target->right->str, target->right->len);
      compile_expr(c, target->left);
      compile_expr(c, node->right);
      emit_op(c, OP_INSERT2);
      emit_atom_idx_op(c, OP_PUT_FIELD, (uint32_t)atom);
      return;
    }
    
    if (target->type == N_MEMBER && (target->flags & 1)) {
      compile_expr(c, target->left);
      compile_expr(c, target->right);
      compile_expr(c, node->right);
      emit_op(c, OP_INSERT3);
      emit_op(c, OP_PUT_ELEM);
      return;
    }
    
    if (can_append_builder) {
      if (is_self_append_inplace_safe_expr(c, append_rhs)) {
        compile_expr(c, append_rhs);
        emit_slot_op(c, OP_STR_APPEND_LOCAL, append_slot);
      } else {
        emit_slot_op(c, OP_GET_SLOT_RAW, append_slot);
        compile_expr(c, append_rhs);
        emit_slot_op(c, OP_STR_ALC_SNAPSHOT, append_slot);
      }
      emit_get_var(c, target->str, target->len);
      set_local_inferred_type(c, append_local, SV_TI_UNKNOWN);
      return;
    }

    compile_expr(c, node->right);
    compile_lhs_set(c, target, true);
    return;
  }

  if (target->type == N_IDENT) {
    int lhs_local = resolve_local(c, target->str, target->len);
    uint8_t lhs_type = (lhs_local >= 0) ? get_local_inferred_type(c, lhs_local) : SV_TI_UNKNOWN;
    uint8_t rhs_type = infer_expr_type(c, node->right);

    if (can_append_builder) {
      if (is_self_append_inplace_safe_expr(c, append_rhs)) {
        compile_expr(c, append_rhs);
        emit_slot_op(c, OP_STR_APPEND_LOCAL, append_slot);
      } else {
        emit_slot_op(c, OP_GET_SLOT_RAW, append_slot);
        compile_expr(c, append_rhs);
        emit_slot_op(c, OP_STR_ALC_SNAPSHOT, append_slot);
      }
      emit_get_var(c, target->str, target->len);
      set_local_inferred_type(c, append_local, SV_TI_UNKNOWN);
      return;
    }

    if (op == TOK_PLUS_ASSIGN) {
      int slot = resolve_local_slot(c, target->str, target->len);
      if (slot >= 0 && !c->locals[slot + c->param_locals].is_const) {
        sv_ast_t *rhs = node->right;
        bool rhs_pure = rhs && (
          rhs->type == N_NUMBER || rhs->type == N_STRING ||
          rhs->type == N_BOOL || rhs->type == N_NULL ||
          rhs->type == N_UNDEF || rhs->type == N_IDENT
        );
        if (rhs_pure) {
          compile_expr(c, rhs);
          emit_op(c, OP_ADD_LOCAL);
          emit(c, (uint8_t)slot);
          emit_get_local(c, c->param_locals + slot);
          set_local_inferred_type(c, c->param_locals + slot, SV_TI_UNKNOWN);
          return;
        }
      }
    }

    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
        op == TOK_NULLISH_ASSIGN) {
      emit_get_var(c, target->str, target->len);
      int skip = emit_jump(c,
        op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
        op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
      emit_op(c, OP_POP);
      compile_expr(c, node->right);
      emit_set_var(c, target->str, target->len, true);
      patch_jump(c, skip);
      return;
    }

    emit_get_var(c, target->str, target->len);
    compile_expr(c, node->right);
    switch (op) {
      case TOK_PLUS_ASSIGN:
        emit_op(c, (lhs_type == SV_TI_NUM && rhs_type == SV_TI_NUM) ? OP_ADD_NUM : OP_ADD);
        break;
      case TOK_MINUS_ASSIGN:
        emit_op(c, (lhs_type == SV_TI_NUM && rhs_type == SV_TI_NUM) ? OP_SUB_NUM : OP_SUB);
        break;
      case TOK_MUL_ASSIGN:
        emit_op(c, (lhs_type == SV_TI_NUM && rhs_type == SV_TI_NUM) ? OP_MUL_NUM : OP_MUL);
        break;
      case TOK_DIV_ASSIGN:
        emit_op(c, (lhs_type == SV_TI_NUM && rhs_type == SV_TI_NUM) ? OP_DIV_NUM : OP_DIV);
        break;
      case TOK_REM_ASSIGN:     emit_op(c, OP_MOD); break;
      case TOK_SHL_ASSIGN:     emit_op(c, OP_SHL); break;
      case TOK_SHR_ASSIGN:     emit_op(c, OP_SHR); break;
      case TOK_ZSHR_ASSIGN:    emit_op(c, OP_USHR); break;
      case TOK_AND_ASSIGN:     emit_op(c, OP_BAND); break;
      case TOK_XOR_ASSIGN:     emit_op(c, OP_BXOR); break;
      case TOK_OR_ASSIGN:      emit_op(c, OP_BOR); break;
      case TOK_EXP_ASSIGN:    emit_op(c, OP_EXP); break;
      default: break;
    }
    emit_set_var(c, target->str, target->len, true);
  } else if (target->type == N_MEMBER && !(target->flags & 1)) {
    int atom = add_atom(c, target->right->str, target->right->len);

    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
        op == TOK_NULLISH_ASSIGN) {
      compile_expr(c, target->left);
      emit_op(c, OP_DUP);
      emit_atom_idx_op(c, OP_GET_FIELD, (uint32_t)atom);
      int skip = emit_jump(c,
        op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
        op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
      emit_op(c, OP_POP);
      compile_expr(c, node->right);
      emit_op(c, OP_INSERT2);
      emit_atom_idx_op(c, OP_PUT_FIELD, (uint32_t)atom);
      int end = emit_jump(c, OP_JMP);
      patch_jump(c, skip);
      emit_op(c, OP_NIP);
      patch_jump(c, end);
      return;
    }

    compile_expr(c, target->left);
    emit_op(c, OP_DUP);
    emit_atom_idx_op(c, OP_GET_FIELD, (uint32_t)atom);
    compile_expr(c, node->right);
    switch (op) {
      case TOK_PLUS_ASSIGN:  emit_op(c, OP_ADD); break;
      case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
      case TOK_MUL_ASSIGN:   emit_op(c, OP_MUL); break;
      case TOK_DIV_ASSIGN:   emit_op(c, OP_DIV); break;
      case TOK_REM_ASSIGN:   emit_op(c, OP_MOD); break;
      case TOK_SHL_ASSIGN:   emit_op(c, OP_SHL); break;
      case TOK_SHR_ASSIGN:   emit_op(c, OP_SHR); break;
      case TOK_ZSHR_ASSIGN:  emit_op(c, OP_USHR); break;
      case TOK_AND_ASSIGN:   emit_op(c, OP_BAND); break;
      case TOK_XOR_ASSIGN:   emit_op(c, OP_BXOR); break;
      case TOK_OR_ASSIGN:    emit_op(c, OP_BOR); break;
      case TOK_EXP_ASSIGN:  emit_op(c, OP_EXP); break;
      default: break;
    }
    emit_op(c, OP_INSERT2);
    emit_atom_idx_op(c, OP_PUT_FIELD, (uint32_t)atom);
  } else if (target->type == N_MEMBER && (target->flags & 1)) {

    if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
        op == TOK_NULLISH_ASSIGN) {
      compile_expr(c, target->left);
      compile_expr(c, target->right);
      emit_op(c, OP_DUP2);
      emit_op(c, OP_GET_ELEM);
      int skip = emit_jump(c,
        op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
        op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
      emit_op(c, OP_POP);
      compile_expr(c, node->right);
      emit_op(c, OP_INSERT3);
      emit_op(c, OP_PUT_ELEM);
      int end = emit_jump(c, OP_JMP);
      patch_jump(c, skip);
      emit_op(c, OP_NIP2);
      patch_jump(c, end);
      return;
    }

    compile_expr(c, target->left);
    compile_expr(c, target->right);
    emit_op(c, OP_DUP2);
    emit_op(c, OP_GET_ELEM);
    compile_expr(c, node->right);
    switch (op) {
      case TOK_PLUS_ASSIGN:  emit_op(c, OP_ADD); break;
      case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
      case TOK_MUL_ASSIGN:   emit_op(c, OP_MUL); break;
      case TOK_DIV_ASSIGN:   emit_op(c, OP_DIV); break;
      case TOK_REM_ASSIGN:   emit_op(c, OP_MOD); break;
      case TOK_SHL_ASSIGN:   emit_op(c, OP_SHL); break;
      case TOK_SHR_ASSIGN:   emit_op(c, OP_SHR); break;
      case TOK_ZSHR_ASSIGN:  emit_op(c, OP_USHR); break;
      case TOK_AND_ASSIGN:   emit_op(c, OP_BAND); break;
      case TOK_XOR_ASSIGN:   emit_op(c, OP_BXOR); break;
      case TOK_OR_ASSIGN:    emit_op(c, OP_BOR); break;
      case TOK_EXP_ASSIGN:  emit_op(c, OP_EXP); break;
      default: break;
    }
    emit_op(c, OP_INSERT3);
    emit_op(c, OP_PUT_ELEM);
  } else {
    compile_expr(c, node->right);
  }
}

void compile_lhs_set(sv_compiler_t *c, sv_ast_t *target, bool keep) {
  if (target->type == N_IDENT) {
    emit_set_var(c, target->str, target->len, keep);
  } else if (target->type == N_MEMBER && !(target->flags & 1)) {
    if (keep) emit_op(c, OP_DUP);
    compile_expr(c, target->left);
    emit_op(c, OP_SWAP);
    emit_atom_op(c, OP_PUT_FIELD, target->right->str, target->right->len);
  } else if (target->type == N_MEMBER && (target->flags & 1)) {
    if (keep) emit_op(c, OP_DUP);
    compile_expr(c, target->left);
    compile_expr(c, target->right);
    emit_op(c, OP_ROT3L);
    emit_op(c, OP_PUT_ELEM);
  } else if (target->type == N_ARRAY_PAT || target->type == N_ARRAY) {
    compile_array_destructure(c, target, keep);
  } else if (target->type == N_OBJECT_PAT || target->type == N_OBJECT) {
    compile_object_destructure(c, target, keep);
  }
}

void compile_ternary(sv_compiler_t *c, sv_ast_t *node) {
  compile_truthy_test_expr(c, node->cond);
  int else_jump = emit_jump(c, OP_JMP_FALSE);
  compile_expr(c, node->left);
  int end_jump = emit_jump(c, OP_JMP);
  patch_jump(c, else_jump);
  compile_expr(c, node->right);
  patch_jump(c, end_jump);
}

void compile_typeof(sv_compiler_t *c, sv_ast_t *node) {
  sv_ast_t *arg = node->right;
  if (arg->type == N_IDENT) {
    int local = resolve_local(c, arg->str, arg->len);
    if (local != -1) {
      uint8_t inferred = get_local_inferred_type(c, local);
      const char *known = typeof_name_for_type(inferred);
      if (known) {
        emit_constant(c, js_mkstr_permanent(c->js, known, strlen(known)));
        return;
      }
      emit_get_var(c, arg->str, arg->len);
    } else {
      int upval = resolve_upvalue(c, arg->str, arg->len);
      if (upval != -1) {
        emit_op(c, OP_GET_UPVAL);
        emit_u16(c, (uint16_t)upval);
      } else if (
          has_implicit_arguments_obj(c) &&
          is_ident_str(arg->str, arg->len, "arguments", 9)
        ) {
        if (c->strict_args_local >= 0) {
          emit_get_local(c, c->strict_args_local);
        } else {
          emit_op(c, OP_SPECIAL_OBJ);
          emit(c, 0);
        }
      } else emit_atom_op(c, OP_GET_GLOBAL_UNDEF, arg->str, arg->len);
    }
  } else compile_expr(c, arg);
  emit_op(c, OP_TYPEOF);
}

static bool sv_node_has_optional_base(sv_ast_t *n) {
  while (n) {
    if (n->type == N_OPTIONAL) return true;
    if (n->type == N_MEMBER || n->type == N_CALL) n = n->left;
    else break;
  }
  return false;
}

static void compile_delete_optional(sv_compiler_t *c, sv_ast_t *arg) {
  compile_expr(c, arg->left);
  int ok_jump = emit_jump(c, OP_JMP_NOT_NULLISH);
  emit_op(c, OP_POP);
  emit_op(c, OP_TRUE);
  int end_jump = emit_jump(c, OP_JMP);
  patch_jump(c, ok_jump);
  if (arg->flags & 1) {
    compile_expr(c, arg->right);
  } else {
    ant_value_t key = js_mkstr_permanent(c->js, arg->right->str, arg->right->len);
    emit_constant(c, key);
  }
  emit_op(c, OP_DELETE);
  patch_jump(c, end_jump);
}

void compile_delete(sv_compiler_t *c, sv_ast_t *node) {
  sv_ast_t *arg = node->right;
  if (arg->type == N_OPTIONAL) {
    compile_delete_optional(c, arg);
  } else if (arg->type == N_MEMBER && sv_node_has_optional_base(arg->left)) {
    compile_delete_optional(c, arg);
  } else if (arg->type == N_MEMBER && !(arg->flags & 1)) {
    compile_expr(c, arg->left);
    ant_value_t key = js_mkstr_permanent(c->js, arg->right->str, arg->right->len);
    emit_constant(c, key);
    emit_op(c, OP_DELETE);
  } else if (arg->type == N_MEMBER && (arg->flags & 1)) {
    compile_expr(c, arg->left);
    compile_expr(c, arg->right);
    emit_op(c, OP_DELETE);
  } else if (arg->type == N_IDENT) {
    emit_atom_op(c, OP_DELETE_VAR, arg->str, arg->len);
  } else {
    compile_expr(c, arg);
    emit_op(c, OP_POP);
    emit_op(c, OP_TRUE);
  }
}

void compile_template(sv_compiler_t *c, sv_ast_t *node) {
  int n = node->args.count;
  if (n == 0) {
    emit_constant(c, js_mkstr_permanent(c->js, "", 0));
    return;
  }
  for (int i = 0; i < n; i++) {
    sv_ast_t *item = node->args.items[i];
    if (is_invalid_cooked_string(item)) {
      static const char msg[] = "Invalid or unexpected token";
      int atom = add_atom(c, msg, sizeof(msg) - 1);
      emit_op(c, OP_THROW_ERROR);
      emit_u32(c, (uint32_t)atom);
      emit(c, (uint8_t)JS_ERR_SYNTAX);
      return;
    }
  }
  compile_expr(c, node->args.items[0]);
  if (!is_template_segment(node->args.items[0]))
    emit_op(c, OP_TO_PROPKEY);
  for (int i = 1; i < n; i++) {
    compile_expr(c, node->args.items[i]);
    if (!is_template_segment(node->args.items[i]))
      emit_op(c, OP_TO_PROPKEY);
    emit_op(c, OP_ADD);
  }
}

static bool call_has_spread_arg(const sv_ast_t *node) {
  if (!node) return false;
  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *arg = node->args.items[i];
    if (arg && arg->type == N_SPREAD) return true;
  }
  return false;
}

static void compile_push_arg_to_array(sv_compiler_t *c, sv_ast_t *arg) {
  emit_op(c, OP_DUP);
  emit_op(c, OP_DUP);
  emit_atom_op(c, OP_GET_FIELD, "push", 4);
  compile_expr(c, arg);
  emit_op(c, OP_CALL_METHOD);
  emit_u16(c, 1);
  emit_op(c, OP_POP);
}

static void compile_concat_spread_to_array(sv_compiler_t *c, sv_ast_t *spread_arg) {
  compile_expr(c, spread_arg->right);
  emit_op(c, OP_SPREAD);
}

static void compile_call_args_array(sv_compiler_t *c, sv_ast_t *call_node) {
  emit_op(c, OP_ARRAY);
  emit_u16(c, 0);
  for (int i = 0; i < call_node->args.count; i++) {
    sv_ast_t *arg = call_node->args.items[i];
    if (arg && arg->type == N_SPREAD) compile_concat_spread_to_array(c, arg);
    else compile_push_arg_to_array(c, arg);
  }
}

typedef enum {
  SV_CALL_DIRECT = 0,
  SV_CALL_METHOD = 1,
  SV_CALL_SUPER = 2,
} sv_call_kind_t;

static inline bool sv_call_kind_has_receiver(sv_call_kind_t kind) {
  return kind == SV_CALL_METHOD || kind == SV_CALL_SUPER;
}

static void compile_receiver_property_get(sv_compiler_t *c, sv_ast_t *node) {
  emit_op(c, OP_DUP);
  if (node->flags & 1) {
    compile_expr(c, node->right);
    emit_op(c, OP_GET_ELEM);
  } else {
    emit_srcpos(c, node->right);
    emit_atom_op(c, OP_GET_FIELD, node->right->str, node->right->len);
  }
}

static void compile_call_emit_invoke(
  sv_compiler_t *c, sv_ast_t *node,
  sv_call_kind_t kind, bool has_spread
) {
  int argc = node->args.count;
  if (has_spread) {
    if (sv_call_kind_has_receiver(kind)) emit_op(c, OP_SWAP);
    else emit_op(c, OP_GLOBAL);
    compile_call_args_array(c, node);
    emit_op(c, kind == SV_CALL_SUPER ? OP_SUPER_APPLY : OP_APPLY);
    emit_u16(c, 1);
    return;
  }

  for (int i = 0; i < argc; i++)
    compile_expr(c, node->args.items[i]);
  emit_op(c, sv_call_kind_has_receiver(kind) ? OP_CALL_METHOD : OP_CALL);
  emit_u16(c, (uint16_t)argc);
}

static sv_call_kind_t compile_call_setup_non_optional(sv_compiler_t *c, sv_ast_t *callee) {
  if (is_ident_name(callee, "super")) {
    emit_op(c, OP_THIS);
    emit_get_var(c, "super", 5);
    return SV_CALL_SUPER;
  }

  if (callee->type == N_MEMBER && is_ident_name(callee->left, "super")) {
    emit_op(c, OP_THIS);
    emit_op(c, OP_THIS);
    emit_get_var(c, "super", 5);
    if (callee->flags & 1)
      compile_expr(c, callee->right);
    else
      emit_constant(c, js_mkstr_permanent(c->js, callee->right->str, callee->right->len));
    emit_op(c, OP_GET_SUPER_VAL);
    return SV_CALL_METHOD;
  }

  if (callee->type == N_MEMBER) {
    compile_expr(c, callee->left);
    compile_receiver_property_get(c, callee);
    return SV_CALL_METHOD;
  }

  compile_expr(c, callee);
  return SV_CALL_DIRECT;
}

static bool compile_call_is_proto_intrinsic(
  sv_compiler_t *c, sv_ast_t *node, bool has_spread
) {
  if (!node || has_spread || node->args.count != 1) return false;
  sv_ast_t *callee = node->left;
  if (!callee || callee->type != N_MEMBER) return false;
  if ((callee->flags & 1) || !callee->right || !callee->right->str) return false;
  if (is_ident_name(callee->left, "super")) return false;
  if (!is_ident_str(callee->right->str, callee->right->len, "isPrototypeOf", 13))
    return false;

  compile_expr(c, callee->left);
  compile_receiver_property_get(c, callee);
  compile_expr(c, node->args.items[0]);
  emit_op(c, OP_CALL_IS_PROTO);
  emit_u16(c, alloc_ic_idx(c));
  return true;
}

static bool compile_call_array_includes_intrinsic(
  sv_compiler_t *c, sv_ast_t *node, bool has_spread
) {
  if (!node || has_spread || node->args.count > UINT16_MAX) return false;
  sv_ast_t *callee = node->left;
  
  if (!callee || callee->type != N_MEMBER) return false;
  if ((callee->flags & 1) || !callee->right || !callee->right->str) return false;
  if (is_ident_name(callee->left, "super")) return false;
  if (!is_ident_str(callee->right->str, callee->right->len, "includes", 8))
    return false;

  compile_expr(c, callee->left);
  compile_receiver_property_get(c, callee);
  for (int i = 0; i < node->args.count; i++)
    compile_expr(c, node->args.items[i]);
  emit_op(c, OP_CALL_ARRAY_INCLUDES);
  emit_u16(c, (uint16_t)node->args.count);
  
  return true;
}

static bool compile_regexp_exec_truthy_intrinsic(
  sv_compiler_t *c, sv_ast_t *node
) {
  if (!node || node->type != N_CALL || call_has_spread_arg(node) || node->args.count != 1)
    return false;
    
  sv_ast_t *callee = node->left;
  if (!callee || callee->type != N_MEMBER) return false;
  if ((callee->flags & 1) || !callee->right || !callee->right->str) return false;
  if (is_ident_name(callee->left, "super")) return false;
  if (!is_ident_str(callee->right->str, callee->right->len, "exec", 4))
    return false;

  compile_expr(c, callee->left);
  compile_receiver_property_get(c, callee);
  compile_expr(c, node->args.items[0]);
  emit_op(c, OP_RE_EXEC_TRUTHY);
  
  return true;
}

static void compile_truthy_test_expr(sv_compiler_t *c, sv_ast_t *node) {
  if (compile_regexp_exec_truthy_intrinsic(c, node)) return;
  compile_expr(c, node);
}

static void compile_optional_call_after_setup(
  sv_compiler_t *c, sv_ast_t *call_node,
  sv_call_kind_t kind, bool has_spread
) {
  emit_op(c, OP_DUP);
  emit_op(c, OP_IS_UNDEF_OR_NULL);
  int j_do_call = emit_jump(c, OP_JMP_FALSE);
  emit_op(c, OP_POP);
  if (sv_call_kind_has_receiver(kind))
    emit_op(c, OP_POP);
  emit_op(c, OP_UNDEF);
  int j_end = emit_jump(c, OP_JMP);
  patch_jump(c, j_do_call);
  compile_call_emit_invoke(c, call_node, kind, has_spread);
  patch_jump(c, j_end);
}

static void compile_call_optional(
  sv_compiler_t *c, sv_ast_t *node,
  sv_ast_t *opt_callee, bool has_spread
) {
  if (opt_callee->right) {
    compile_expr(c, opt_callee->left);
    emit_op(c, OP_DUP);
    emit_op(c, OP_IS_UNDEF_OR_NULL);
    int j_have_obj = emit_jump(c, OP_JMP_FALSE);
    emit_op(c, OP_POP);
    emit_op(c, OP_UNDEF);
    int j_end = emit_jump(c, OP_JMP);
    patch_jump(c, j_have_obj);

    compile_receiver_property_get(c, opt_callee);
    compile_call_emit_invoke(c, node, SV_CALL_METHOD, has_spread);
    patch_jump(c, j_end);
    
    return;
  }

  sv_ast_t *target = opt_callee->left;
  if (target && target->type == N_OPTIONAL && target->right) {
    compile_expr(c, target->left);
    emit_op(c, OP_DUP);
    emit_op(c, OP_IS_UNDEF_OR_NULL);
    int j_have_obj = emit_jump(c, OP_JMP_FALSE);
    emit_op(c, OP_POP);
    emit_op(c, OP_UNDEF);
    int j_end = emit_jump(c, OP_JMP);
    patch_jump(c, j_have_obj);

    compile_receiver_property_get(c, target);
    compile_optional_call_after_setup(c, node, SV_CALL_METHOD, has_spread);
    patch_jump(c, j_end);
    return;
  }

  sv_call_kind_t kind = compile_call_setup_non_optional(c, target);
  compile_optional_call_after_setup(c, node, kind, has_spread);
}

void compile_call(sv_compiler_t *c, sv_ast_t *node) {
  sv_ast_t *callee = node->left;
  bool has_spread = call_has_spread_arg(node);

  if (callee->type == N_OPTIONAL) {
    compile_call_optional(c, node, callee, has_spread);
    return;
  }

  if (compile_call_is_proto_intrinsic(c, node, has_spread))
    return;

  if (compile_call_array_includes_intrinsic(c, node, has_spread))
    return;

  if (
    !has_spread && node->args.count >= 2 &&
    callee->type == N_MEMBER &&
    is_ident_name(callee->left, "Ant") &&
    resolve_local(c, "Ant", 3) == -1 &&
    callee->right && callee->right->type == N_IDENT &&
    callee->right->len == 5 && memcmp(callee->right->str, "match", 5) == 0 &&
    node->args.items[1]->type == N_OBJECT
  ) {
    sv_ast_t *obj = node->args.items[1];
    sv_ast_t *param = sv_ast_new(N_IDENT);
    
    param->str = "$"; param->len = 1;
    sv_ast_t *arrow = sv_ast_new(N_FUNC);
    
    arrow->flags = FN_ARROW;
    arrow->body = obj;
    arrow->line = obj->line; arrow->col = obj->col;
    arrow->src_off = obj->src_off; arrow->src_end = obj->src_end;
    
    sv_ast_list_push(&arrow->args, param);
    node->args.items[1] = arrow;
  }

  if (!has_spread && is_ident_name(callee, "eval")) {
    if (node->args.count > 0)
      compile_expr(c, node->args.items[0]);
    else
      emit_op(c, OP_UNDEF);
    for (int i = 1; i < node->args.count; i++) {
      compile_expr(c, node->args.items[i]);
      emit_op(c, OP_POP);
    }
    
    emit_op(c, OP_EVAL);
    emit_u32(c, 0);
    
    return;
  }

  if (callee->type == N_MEMBER && sv_node_has_optional_base(callee->left)) {
    compile_expr(c, callee->left);
    int ok_jump  = emit_jump(c, OP_JMP_NOT_NULLISH);
    emit_op(c, OP_POP);
    emit_op(c, OP_UNDEF);
    int end_jump = emit_jump(c, OP_JMP);
    patch_jump(c, ok_jump);
    compile_receiver_property_get(c, callee);
    compile_call_emit_invoke(c, node, SV_CALL_METHOD, has_spread);
    patch_jump(c, end_jump);
    return;
  }

  sv_call_kind_t kind = compile_call_setup_non_optional(c, callee);
  compile_call_emit_invoke(c, node, kind, has_spread);
}

void compile_new(sv_compiler_t *c, sv_ast_t *node) {
  compile_expr(c, node->left);
  emit_op(c, OP_DUP);
  if (call_has_spread_arg(node)) {
    compile_call_args_array(c, node);
    emit_op(c, OP_NEW_APPLY);
    emit_u16(c, 1);
  } else {
    int argc = node->args.count;
    for (int i = 0; i < argc; i++)
      compile_expr(c, node->args.items[i]);
    emit_op(c, OP_NEW);
    emit_u16(c, (uint16_t)argc);
  }
}

void compile_member(sv_compiler_t *c, sv_ast_t *node) {
  if (is_ident_name(node->left, "super")) {
    emit_op(c, OP_THIS);
    emit_get_var(c, "super", 5);
    if (node->flags & 1)
      compile_expr(c, node->right);
    else
      emit_constant(c, js_mkstr_permanent(c->js, node->right->str, node->right->len));
    emit_op(c, OP_GET_SUPER_VAL);
    return;
  }

  compile_expr(c, node->left);

  int ok_jump = -1, end_jump = -1;
  if (sv_node_has_optional_base(node->left)) {
    ok_jump  = emit_jump(c, OP_JMP_NOT_NULLISH);
    end_jump = emit_jump(c, OP_JMP);
    patch_jump(c, ok_jump);
  }

  if (node->flags & 1) {
    compile_expr(c, node->right);
    emit_op(c, OP_GET_ELEM);
  } else {
    if (node->right->len == 6 && memcmp(node->right->str, "length", 6) == 0)
      emit_op(c, OP_GET_LENGTH);
    else {
      emit_srcpos(c, node->right);
      emit_atom_op(c, OP_GET_FIELD, node->right->str, node->right->len);
    }
  }

  if (end_jump >= 0) patch_jump(c, end_jump);
}

void compile_optional_get(sv_compiler_t *c, sv_ast_t *node) {
  if (node->flags & 1) {
    compile_expr(c, node->right);
    emit_op(c, OP_GET_ELEM_OPT);
  } else {
    emit_srcpos(c, node->right);
    emit_atom_op(c, OP_GET_FIELD_OPT, node->right->str, node->right->len);
  }
}

void compile_optional(sv_compiler_t *c, sv_ast_t *node) {
  compile_expr(c, node->left);
  compile_optional_get(c, node);
}

void compile_array(sv_compiler_t *c, sv_ast_t *node) {
  int count = node->args.count;
  bool has_spread = false;
  for (int i = 0; i < count; i++) {
    sv_ast_t *elem = node->args.items[i];
    if (elem && elem->type == N_SPREAD) {
      has_spread = true;
      break;
    }
  }

  if (!has_spread) {
    for (int i = 0; i < count; i++) {
      sv_ast_t *elem = node->args.items[i];
      if (elem && elem->type == N_EMPTY)
        emit_op(c, OP_EMPTY);
      else
        compile_expr(c, elem);
    }
    emit_op(c, OP_ARRAY);
    emit_u16(c, (uint16_t)count);
    return;
  }

  emit_op(c, OP_ARRAY);
  emit_u16(c, 0);
  for (int i = 0; i < count; i++) {
    sv_ast_t *elem = node->args.items[i];
    if (elem && elem->type == N_SPREAD) compile_concat_spread_to_array(c, elem);
    else compile_push_arg_to_array(c, elem);
  }
}

void compile_object(sv_compiler_t *c, sv_ast_t *node) {
  emit_op(c, OP_OBJECT);
  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *prop = node->args.items[i];
    if (prop->type == N_SPREAD) {
      compile_expr(c, prop->right);
      emit_op(c, OP_COPY_DATA_PROPS);
      emit(c, 0);
      emit_op(c, OP_POP);
      continue;
    }
    
    if (prop->type != N_PROPERTY) continue;
    if (prop->flags & FN_GETTER || prop->flags & FN_SETTER) {
      compile_expr(c, prop->right);
      uint8_t flags = 0;
      if (prop->flags & FN_GETTER) flags |= 1;
      if (prop->flags & FN_SETTER) flags |= 2;
      if (prop->flags & FN_COMPUTED) compile_expr(c, prop->left);
      else compile_static_property_key(c, prop->left);
      emit_op(c, OP_SWAP);
      emit_op(c, OP_DEFINE_METHOD_COMP);
      emit(c, flags);
    } else if (prop->flags & FN_COMPUTED) {
      compile_expr(c, prop->left);
      compile_expr(c, prop->right);
      emit_op(c, OP_DEFINE_METHOD_COMP);
      emit(c, 0);
    } else {
      if (prop->right && (prop->right->type == N_FUNC || prop->right->type == N_CLASS) &&
          (!prop->right->str || prop->right->len == 0) &&
          prop->left && prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left)) {
        c->inferred_name = prop->left->str;
        c->inferred_name_len = prop->left->len;
      }
      compile_expr(c, prop->right);
      if ((prop->flags & FN_COLON) &&
          prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left) &&
          is_ident_str(prop->left->str, prop->left->len, "__proto__", 9)) {
        emit_op(c, OP_SET_PROTO);
        continue;
      }
      if (prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left)) {
        emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str, prop->left->len);
      } else if (is_quoted_ident_key(prop->left)) {
        emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str + 1, prop->left->len - 2);
      } else if (prop->left->type == N_STRING) {
        emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str ? prop->left->str : "", prop->left->len);
      } else if (prop->left->type == N_NUMBER) {
        char buf[32];
        int n = snprintf(buf, sizeof(buf), "%g", prop->left->num);
        emit_atom_op(c, OP_DEFINE_FIELD, buf, (uint32_t)n);
      } else emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str, prop->left->len);
    }
  }
}

void compile_func_expr(sv_compiler_t *c, sv_ast_t *node) {
  bool has_name = node->str && node->len > 0 && !(node->flags & FN_ARROW);
  int name_local = -1;

  if (has_name) {
    begin_scope(c);
    name_local = add_local(c, node->str, node->len, true, c->scope_depth);
    emit_op(c, OP_UNDEF);
    emit_put_local(c, name_local);
  }

  sv_func_t *fn = compile_function_body(c, node, SV_COMPILE_SCRIPT);
  if (!fn) {
    emit_op(c, OP_UNDEF);
    if (has_name) end_scope(c);
    return;
  }
  
  int idx = add_constant(c, mkval(T_NTARG, (uintptr_t)fn));
  emit_op(c, OP_CLOSURE);
  emit_u32(c, (uint32_t)idx);

  if (node->str && node->len > 0) {
    emit_set_function_name(c, node->str, node->len);
  } else if (c->inferred_name) {
    emit_set_function_name(c, c->inferred_name, c->inferred_name_len);
    c->inferred_name = NULL;
    c->inferred_name_len = 0;
  } else {
    emit_set_function_name(c, NULL, 0);
  }

  if (has_name) {
    emit_op(c, OP_DUP);
    emit_put_local(c, name_local);
    end_scope(c);
  }
}

typedef enum {
  DESTRUCTURE_ASSIGN = 0,
  DESTRUCTURE_BIND   = 1,
} sv_destructure_mode_t;

static void emit_build_object_rest(sv_compiler_t *c) {
  emit_op(c, OP_DUP);
  emit_op(c, OP_OBJECT);
  emit_op(c, OP_SWAP);
  emit_op(c, OP_COPY_DATA_PROPS);
  emit(c, 0);
  emit_op(c, OP_POP);
}

static void emit_delete_rest_key(sv_compiler_t *c, sv_ast_t *key) {
  emit_op(c, OP_DUP);
  if (key->type == N_IDENT) {
    emit_constant(c, js_mkstr_permanent(c->js, key->str, key->len));
  } else if (key->type == N_STRING) {
    emit_constant(c, ast_string_const(c, key));
  } else if (key->type == N_NUMBER) {
    emit_number(c, key->num);
  } else {
    compile_expr(c, key);
  }
  emit_op(c, OP_DELETE);
  emit_op(c, OP_POP);
}

static bool is_destructure_pattern_node(sv_ast_t *node) {
  return node && (node->type == N_ARRAY_PAT || node->type == N_ARRAY ||
                  node->type == N_OBJECT_PAT || node->type == N_OBJECT);
}

static void compile_destructure_pattern(sv_compiler_t *c, sv_ast_t *pat,
                                        bool keep, bool consume_source,
                                        sv_destructure_mode_t mode,
                                        sv_var_kind_t kind);

static void compile_destructure_store(sv_compiler_t *c, sv_ast_t *target,
                                      sv_destructure_mode_t mode,
                                      sv_var_kind_t kind) {
  if (!target) return;

  if (mode == DESTRUCTURE_ASSIGN) {
    compile_lhs_set(c, target, false);
    return;
  }

  if (target->type == N_IDENT) {
    bool is_const = (kind == SV_VAR_CONST);
    int idx = ensure_local_at_depth(c, target->str, target->len,
                                    is_const, c->scope_depth);
    emit_put_local(c, idx);
    return;
  }

  if (is_destructure_pattern_node(target)) {
    compile_destructure_pattern(c, target, false, true, mode, kind);
    return;
  }

  compile_lhs_set(c, target, false);
}

static void compile_destructure_pattern(
  sv_compiler_t *c, sv_ast_t *pat,
  bool keep, bool consume_source,
  sv_destructure_mode_t mode,
  sv_var_kind_t kind
) {
  if (!pat) return;
  if (keep) emit_op(c, OP_DUP);

  if (pat->type == N_ARRAY_PAT || pat->type == N_ARRAY) {
    if (!consume_source && !keep) emit_op(c, OP_DUP);
    emit_op(c, OP_DESTRUCTURE_INIT);
    
    int err_local = add_local(c, "", 0, false, c->scope_depth);
    int try_jump = emit_jump(c, OP_TRY_PUSH);
    c->try_depth++;
    
    for (int i = 0; i < pat->args.count; i++) {
      sv_ast_t *elem = pat->args.items[i];
      if (!elem || elem->type == N_EMPTY) {
        emit_op(c, OP_DESTRUCTURE_NEXT);
        emit_op(c, OP_POP);
        continue;
      }
      
      if (elem->type == N_REST || elem->type == N_SPREAD) {
        emit_op(c, OP_DESTRUCTURE_REST);
        compile_destructure_store(c, elem->right, mode, kind);
        continue;
      }
      
      sv_ast_t *target = elem;
      sv_ast_t *default_val = NULL;
      if (elem->type == N_ASSIGN_PAT ||
          (elem->type == N_ASSIGN && elem->op == TOK_ASSIGN)) {
        target = elem->left;
        default_val = elem->right;
      }
      
      emit_op(c, OP_DESTRUCTURE_NEXT);
      
      if (default_val) {
        emit_op(c, OP_DUP);
        emit_op(c, OP_IS_UNDEF);
        int skip = emit_jump(c, OP_JMP_FALSE);
        emit_op(c, OP_POP);
        compile_expr(c, default_val);
        patch_jump(c, skip);
      }
      
      compile_destructure_store(c, target, mode, kind);
    }

    emit_op(c, OP_TRY_POP);
    emit_op(c, OP_DESTRUCTURE_CLOSE);
    int end_jump = emit_jump(c, OP_JMP);

    patch_jump(c, try_jump);
    int catch_tag = emit_jump(c, OP_CATCH);
    
    emit_put_local(c, err_local);
    emit_op(c, OP_DESTRUCTURE_CLOSE);
    emit_get_local(c, err_local);
    emit_op(c, OP_THROW);
    patch_jump(c, catch_tag);
    patch_jump(c, end_jump);
    c->try_depth--;
    
    return;
  } else if (pat->type == N_OBJECT_PAT || pat->type == N_OBJECT) {
    for (int i = 0; i < pat->args.count; i++) {
      sv_ast_t *prop = pat->args.items[i];
      if (!prop) continue;

      if (prop->type == N_REST || prop->type == N_SPREAD) {
        emit_build_object_rest(c);
        for (int j = 0; j < i; j++) {
          sv_ast_t *prev = pat->args.items[j];
          if (!prev || prev->type != N_PROPERTY || !prev->left) continue;
          emit_delete_rest_key(c, prev->left);
        }
        compile_destructure_store(c, prop->right, mode, kind);
        continue;
      }
      if (prop->type != N_PROPERTY) continue;

      sv_ast_t *key = prop->left;
      sv_ast_t *value = prop->right;
      sv_ast_t *default_val = NULL;
      if (value && (value->type == N_ASSIGN_PAT ||
                    (value->type == N_ASSIGN && value->op == TOK_ASSIGN))) {
        default_val = value->right;
        value = value->left;
      }

      emit_op(c, OP_DUP);
      if ((prop->flags & FN_COMPUTED)) {
        compile_expr(c, key);
        emit_op(c, OP_GET_ELEM);
      } else if (key->type == N_IDENT) {
        emit_atom_op(c, OP_GET_FIELD, key->str, key->len);
      } else {
        compile_expr(c, key);
        emit_op(c, OP_GET_ELEM);
      }

      if (default_val) {
        emit_op(c, OP_DUP);
        emit_op(c, OP_IS_UNDEF);
        int skip = emit_jump(c, OP_JMP_FALSE);
        emit_op(c, OP_POP);
        compile_expr(c, default_val);
        patch_jump(c, skip);
      }

      compile_destructure_store(c, value, mode, kind);
    }
  }

  if (consume_source) emit_op(c, OP_POP);
}

void compile_array_destructure(sv_compiler_t *c, sv_ast_t *pat, bool keep) {
  compile_destructure_pattern(c, pat, keep, true, DESTRUCTURE_ASSIGN, SV_VAR_LET);
}

void compile_object_destructure(sv_compiler_t *c, sv_ast_t *pat, bool keep) {
  compile_destructure_pattern(c, pat, keep, true, DESTRUCTURE_ASSIGN, SV_VAR_LET);
}

static bool is_tail_callable(sv_compiler_t *c, sv_ast_t *node) {
  if (c->try_depth > 0) return false;
  if (c->using_cleanup_count > 0) return false;
  if (node->type != N_CALL) return false;
  if (call_has_spread_arg(node)) return false;
  
  sv_ast_t *callee = node->left;
  if (
    callee->type == N_IDENT && 
    callee->len == 5 && memcmp(callee->str, "super", 5) == 0
  ) return false;
  
  return true;
}

static void emit_using_dispose_call(
  sv_compiler_t *c,
  int stack_local,
  int completion_local,
  bool is_async,
  bool suppressed_completion
) {
  emit_get_local(c, stack_local);
  if (suppressed_completion) {
    emit_get_local(c, completion_local);
  }
  if (is_async && suppressed_completion) emit_op(c, OP_USING_DISPOSE_ASYNC_SUPPRESSED);
  else if (is_async) emit_op(c, OP_USING_DISPOSE_ASYNC);
  else if (suppressed_completion) emit_op(c, OP_USING_DISPOSE_SUPPRESSED);
  else emit_op(c, OP_USING_DISPOSE);
  if (is_async) emit_op(c, OP_AWAIT);
}

static void emit_using_cleanups_to_depth(sv_compiler_t *c, int target_depth) {
for (int i = c->using_cleanup_count - 1; i >= 0; i--) {
  sv_using_cleanup_t *cleanup = &c->using_cleanups[i];
  if (cleanup->scope_depth <= target_depth) break;
  emit_using_dispose_call(c, cleanup->stack_local, -1, cleanup->is_async, false);
  emit_op(c, OP_POP);
}}

static void emit_return_from_stack(sv_compiler_t *c) {
  emit_using_cleanups_to_depth(c, -1);
  emit_close_upvals(c);
  emit_op(c, OP_RETURN);
}

static void compile_tail_call(sv_compiler_t *c, sv_ast_t *node) {
  sv_ast_t *callee = node->left;

  if (callee->type == N_OPTIONAL) {
    compile_call(c, node);
    emit_return_from_stack(c);
    return;
  }

  sv_call_kind_t kind = compile_call_setup_non_optional(c, callee);
  int argc = node->args.count;
  for (int i = 0; i < argc; i++)
    compile_expr(c, node->args.items[i]);

  emit_close_upvals(c);
  emit_op(c, kind == SV_CALL_METHOD ? OP_TAIL_CALL_METHOD : OP_TAIL_CALL);
  emit_u16(c, (uint16_t)argc);
}

void compile_tail_return_expr(sv_compiler_t *c, sv_ast_t *expr) {
  if (expr->type == N_TERNARY) {
    compile_truthy_test_expr(c, expr->cond);
    int else_jump = emit_jump(c, OP_JMP_FALSE);
    compile_tail_return_expr(c, expr->left);
    patch_jump(c, else_jump);
    compile_tail_return_expr(c, expr->right);
    return;
  }

  if (expr->type == N_AWAIT && c->is_async && c->try_depth == 0 && !c->is_tla &&
      c->using_cleanup_count == 0) {
    compile_expr(c, expr->right);
    emit_return_from_stack(c);
    return;
  }

  if (is_tail_callable(c, expr)) {
    compile_tail_call(c, expr);
    return;
  }

  compile_expr(c, expr);
  emit_return_from_stack(c);
}

void compile_stmts(sv_compiler_t *c, sv_ast_list_t *list) {
  for (int i = 0; i < list->count; i++) compile_stmt(c, list->items[i]);
}

static bool stmt_list_has_using_decl(sv_ast_list_t *list, bool *has_await_using) {
  bool found = false;
  for (int i = 0; i < list->count; i++) {
    sv_ast_t *node = list->items[i];
    if (!node) continue;
    
    sv_ast_t *decl = (node->type == N_EXPORT) ? node->left : node;
    if (!decl || decl->type != N_VAR) continue;
    
    if (decl->var_kind == SV_VAR_USING || decl->var_kind == SV_VAR_AWAIT_USING) {
      if (decl->var_kind == SV_VAR_AWAIT_USING && has_await_using) *has_await_using = true;
      found = true;
    }
  }
  
  return found;
}

static void emit_empty_disposal_stack(sv_compiler_t *c) {
  emit_op(c, OP_ARRAY);
  emit_u16(c, 0);
}

static void emit_using_push(sv_compiler_t *c, bool is_async) {
  emit_op(c, is_async ? OP_USING_PUSH_ASYNC : OP_USING_PUSH);
}

static void pop_using_cleanup(sv_compiler_t *c) {
  if (c->using_cleanup_count > 0) c->using_cleanup_count--;
}

static void emit_dispose_resource(sv_compiler_t *c, bool is_async) {
  emit_op(c, is_async ? OP_DISPOSE_RESOURCE_ASYNC : OP_DISPOSE_RESOURCE);
  if (is_async) emit_op(c, OP_AWAIT);
}

static void push_using_cleanup(
  sv_compiler_t *c,
  int stack_local,
  int scope_depth,
  bool is_async
) {
  if (c->using_cleanup_count >= c->using_cleanup_cap) {
    int cap = c->using_cleanup_cap ? c->using_cleanup_cap * 2 : 4;
    c->using_cleanups = realloc(c->using_cleanups, (size_t)cap * sizeof(sv_using_cleanup_t));
    c->using_cleanup_cap = cap;
  }

  c->using_cleanups[c->using_cleanup_count++] = (sv_using_cleanup_t){
    .stack_local = stack_local,
    .scope_depth = scope_depth,
    .is_async = is_async,
  };
}

static void compile_block_with_using(sv_compiler_t *c, sv_ast_t *node) {
  bool has_await_using = false;
  bool has_using = stmt_list_has_using_decl(&node->args, &has_await_using);

  begin_scope(c);
  hoist_lexical_decls(c, &node->args);
  hoist_func_decls(c, &node->args);

  if (!has_using) {
    compile_stmts(c, &node->args);
    end_scope(c);
    return;
  }

  emit_empty_disposal_stack(c);
  int stack_local = add_local(c, "", 0, false, c->scope_depth);
  
  emit_put_local(c, stack_local);
  int err_local = add_local(c, "", 0, false, c->scope_depth);

  int old_using_stack = c->using_stack_local;
  bool old_using_async = c->using_stack_async;
  
  c->using_stack_local = stack_local;
  c->using_stack_async = has_await_using;
  push_using_cleanup(c, stack_local, c->scope_depth, has_await_using);

  c->try_depth++;
  int try_jump = emit_jump(c, OP_TRY_PUSH);
  compile_stmts(c, &node->args);
  emit_op(c, OP_TRY_POP);
  c->try_depth--;

  emit_using_dispose_call(c, stack_local, -1, has_await_using, false);
  emit_op(c, OP_POP);
  int end_jump = emit_jump(c, OP_JMP);

  patch_jump(c, try_jump);
  int catch_tag = emit_jump(c, OP_CATCH);
  
  emit_put_local(c, err_local);
  emit_using_dispose_call(c, stack_local, err_local, has_await_using, true);
  
  if (!has_await_using) emit_op(c, OP_THROW);
  patch_jump(c, catch_tag);
  patch_jump(c, end_jump);

  c->using_stack_local = old_using_stack;
  c->using_stack_async = old_using_async;
  
  pop_using_cleanup(c);
  end_scope(c);
}

void compile_stmt(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) return;
  emit_srcpos(c, node);

  switch (node->type) {
    case N_EMPTY:
    case N_DEBUGGER:
      break;

    case N_BLOCK:
      compile_block_with_using(c, node);
      break;

    case N_VAR:
      compile_var_decl(c, node);
      break;

    case N_IMPORT_DECL:
      compile_import_decl(c, node);
      break;

    case N_EXPORT:
      compile_export_decl(c, node);
      break;

    case N_IF:
      compile_if(c, node);
      break;

    case N_WHILE:
      compile_while(c, node);
      break;

    case N_DO_WHILE:
      compile_do_while(c, node);
      break;

    case N_FOR:
      compile_for(c, node);
      break;

    case N_FOR_IN:
      compile_for_in(c, node);
      break;

    case N_FOR_OF:
      compile_for_of(c, node);
      break;

    case N_FOR_AWAIT_OF:
      if (c->enclosing && !c->enclosing->enclosing) c->is_tla = true;
      compile_for_of(c, node);
      break;

    case N_RETURN:
      if (node->right) {
        compile_tail_return_expr(c, node->right);
      } else {
        emit_op(c, OP_UNDEF);
        emit_return_from_stack(c);
      }
      break;

    case N_THROW:
      compile_expr(c, node->right);
      emit_op(c, OP_THROW);
      break;

    case N_BREAK:
      compile_break(c, node);
      break;

    case N_CONTINUE:
      compile_continue(c, node);
      break;

    case N_TRY:
      compile_try(c, node);
      break;

    case N_SWITCH:
      compile_switch(c, node);
      break;

    case N_LABEL:
      compile_label(c, node);
      break;

    case N_ASSIGN:
      if (compile_self_append_stmt(c, node)) break;
      compile_expr(c, node);
      emit_op(c, OP_POP);
      break;

    case N_FUNC:
      if (node->str && !(node->flags & FN_ARROW)) break;
      compile_expr(c, node);
      emit_op(c, OP_POP);
      break;

    case N_CLASS:
      compile_class(c, node);
      emit_op(c, OP_POP);
      break;

    case N_WITH:
      compile_expr(c, node->left);
      emit_op(c, OP_ENTER_WITH);
      c->with_depth++;
      compile_stmt(c, node->body);
      c->with_depth--;
      emit_op(c, OP_EXIT_WITH);
      break;

    default:
      compile_expr(c, node);
      emit_op(c, OP_POP);
      break;
  }
}

enum {
  IMPORT_BIND_DEFAULT   = 1 << 0,
  IMPORT_BIND_NAMESPACE = 1 << 1,
};

void compile_import_decl(sv_compiler_t *c, sv_ast_t *node) {
  if (!node->right) return;
  bool repl_top = is_repl_top_level(c);

  compile_expr(c, node->right);
  emit_op(c, OP_IMPORT_SYNC);

  if (node->args.count == 0) {
    emit_op(c, OP_POP);
    return;
  }

  int ns_local = add_local(c, "", 0, false, c->scope_depth);
  emit_put_local(c, ns_local);

  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *spec = node->args.items[i];
    if (!spec || spec->type != N_IMPORT_SPEC ||
        !spec->right || spec->right->type != N_IDENT)
      continue;

    emit_get_local(c, ns_local);

    if (!(spec->flags & IMPORT_BIND_NAMESPACE)) {
      if ((spec->flags & IMPORT_BIND_DEFAULT) ||
          !spec->left || spec->left->type != N_IDENT) {
        emit_op(c, OP_IMPORT_DEFAULT);
      } else {
        emit_atom_op(c, OP_IMPORT_NAMED, spec->left->str, spec->left->len);
      }
    }

    if (repl_top) {
      emit_atom_op(c, OP_PUT_GLOBAL, spec->right->str, spec->right->len);
    } else {
      int idx = ensure_local_at_depth(c, spec->right->str, spec->right->len,
                                      true, c->scope_depth);
      emit_put_local(c, idx);
    }
  }
}

static void compile_export_emit(sv_compiler_t *c, const char *name, uint32_t len) {
  emit_get_var(c, name, len);
  emit_atom_op(c, OP_EXPORT, name, len);
}

static void defer_export(sv_compiler_t *c, const char *name, uint32_t len) {
  if (c->deferred_export_count >= c->deferred_export_cap) {
    int cap = c->deferred_export_cap ? c->deferred_export_cap * 2 : 8;
    c->deferred_exports = realloc(c->deferred_exports, cap * sizeof(sv_deferred_export_t));
    c->deferred_export_cap = cap;
  }
  c->deferred_exports[c->deferred_export_count++] =
    (sv_deferred_export_t){ .name = name, .len = len };
}

static void defer_export_pattern(sv_compiler_t *c, sv_ast_t *pat) {
  if (!pat) return;
  switch (pat->type) {
    case N_IDENT:
      defer_export(c, pat->str, pat->len);
      break;
    case N_ASSIGN_PAT:
      defer_export_pattern(c, pat->left);
      break;
    case N_REST:
    case N_SPREAD:
      defer_export_pattern(c, pat->right);
      break;
    case N_ARRAY:
    case N_ARRAY_PAT:
      for (int i = 0; i < pat->args.count; i++)
        defer_export_pattern(c, pat->args.items[i]);
      break;
    case N_OBJECT:
    case N_OBJECT_PAT:
      for (int i = 0; i < pat->args.count; i++) {
        sv_ast_t *prop = pat->args.items[i];
        if (!prop) continue;
        if (prop->type == N_PROPERTY) defer_export_pattern(c, prop->right);
        else defer_export_pattern(c, prop);
      }
      break;
    default:
      break;
  }
}

static void compile_export_pattern(sv_compiler_t *c, sv_ast_t *pat) {
  if (!pat) return;
  switch (pat->type) {
    case N_IDENT:
      compile_export_emit(c, pat->str, pat->len);
      break;
    case N_ASSIGN_PAT:
      compile_export_pattern(c, pat->left);
      break;
    case N_REST:
    case N_SPREAD:
      compile_export_pattern(c, pat->right);
      break;
    case N_ARRAY:
    case N_ARRAY_PAT:
      for (int i = 0; i < pat->args.count; i++)
        compile_export_pattern(c, pat->args.items[i]);
      break;
    case N_OBJECT:
    case N_OBJECT_PAT:
      for (int i = 0; i < pat->args.count; i++) {
        sv_ast_t *prop = pat->args.items[i];
        if (!prop) continue;
        if (prop->type == N_PROPERTY) compile_export_pattern(c, prop->right);
        else compile_export_pattern(c, prop);
      }
      break;
    default:
      break;
  }
}

void compile_export_decl(sv_compiler_t *c, sv_ast_t *node) {
  if (!node) return;

  if (node->flags & EX_DEFAULT) {
    if (node->left) compile_expr(c, node->left);
    else emit_op(c, OP_UNDEF);
    emit_atom_op(c, OP_EXPORT, "default", 7);
    return;
  }

  if ((node->flags & EX_DECL) && node->left) {
    sv_ast_t *decl = node->left;
    if (decl->type == N_VAR) {
      compile_var_decl(c, decl);
      bool is_var = decl->var_kind == SV_VAR_VAR;
      for (int i = 0; i < decl->args.count; i++) {
        sv_ast_t *var = decl->args.items[i];
        if (!var || var->type != N_VARDECL) continue;
        if (is_var && c->mode == SV_COMPILE_MODULE)
          defer_export_pattern(c, var->left);
        else
          compile_export_pattern(c, var->left);
      }
      return;
    }

    compile_stmt(c, decl);
    if ((decl->type == N_FUNC || decl->type == N_CLASS) &&
        decl->str && decl->len > 0) {
      compile_export_emit(c, decl->str, decl->len);
    }
    return;
  }

  if ((node->flags & EX_STAR) && (node->flags & EX_FROM) && node->right) {
    compile_expr(c, node->right);
    emit_op(c, OP_IMPORT_SYNC);

    if (node->flags & EX_NAMESPACE) {
      if (node->args.count > 0) {
        sv_ast_t *spec = node->args.items[0];
        if (spec && spec->type == N_IMPORT_SPEC &&
            spec->right && spec->right->type == N_IDENT) {
          emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
          return;
        }
      }
      emit_op(c, OP_POP);
      return;
    }

    emit_op(c, OP_EXPORT_ALL);
    return;
  }

  if (!(node->flags & EX_NAMED) || node->args.count == 0) return;

  int ns_local = -1;
  if (node->flags & EX_FROM) {
    if (!node->right) return;
    compile_expr(c, node->right);
    emit_op(c, OP_IMPORT_SYNC);
    ns_local = add_local(c, "", 0, false, c->scope_depth);
    emit_put_local(c, ns_local);
  }

  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *spec = node->args.items[i];
    if (!spec || spec->type != N_IMPORT_SPEC || !spec->left || !spec->right ||
        spec->left->type != N_IDENT || spec->right->type != N_IDENT)
      continue;

    if (node->flags & EX_FROM) {
      emit_get_local(c, ns_local);
      if (spec->left->len == 7 && memcmp(spec->left->str, "default", 7) == 0)
        emit_op(c, OP_IMPORT_DEFAULT);
      else
        emit_atom_op(c, OP_IMPORT_NAMED, spec->left->str, spec->left->len);
      emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
    } else {
      emit_get_var(c, spec->left->str, spec->left->len);
      emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
    }
  }
}

void compile_var_decl(sv_compiler_t *c, sv_ast_t *node) {
  sv_var_kind_t kind = node->var_kind;
  bool is_using = (kind == SV_VAR_USING || kind == SV_VAR_AWAIT_USING);
  bool is_await_using = (kind == SV_VAR_AWAIT_USING);
  bool is_const = (kind == SV_VAR_CONST || is_using);
  bool repl_top = is_repl_top_level(c);

  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *decl = node->args.items[i];
    if (decl->type != N_VARDECL) continue;
    sv_ast_t *target = decl->left;

    if (repl_top) {
      if (!decl->right && kind == SV_VAR_VAR) continue;
      if (decl->right) {
        compile_expr(c, decl->right);
      } else {
        emit_op(c, OP_UNDEF);
      }
      if (target->type == N_IDENT) {
        emit_atom_op(c, OP_PUT_GLOBAL, target->str, target->len);
      } else {
        compile_destructure_pattern(c, target, false, true,
                                    DESTRUCTURE_ASSIGN, kind);
      }
    } else if (kind == SV_VAR_VAR) {
      if (decl->right) {
        uint8_t init_type = infer_expr_type(c, decl->right);
        compile_expr(c, decl->right);
        if (target->type == N_IDENT) {
          int idx = resolve_local(c, target->str, target->len);
          if (idx >= 0 && c->locals[idx].depth != -1)
            emit_put_local_typed(c, idx, init_type);
          else
            compile_lhs_set(c, target, false);
        } else {
          compile_lhs_set(c, target, false);
        }
      }
    } else {
      if (target->type == N_IDENT) {
        int idx = ensure_local_at_depth(c, target->str, target->len,
                                        is_const, c->scope_depth);
        uint8_t init_type = SV_TI_UNKNOWN;
        if (decl->right) {
          init_type = infer_expr_type(c, decl->right);
          compile_expr(c, decl->right);
        } else if (!is_const) {
          emit_op(c, OP_UNDEF);
          init_type = SV_TI_UNDEF;
        }
        if (decl->right || !is_const) {
          emit_put_local_typed(c, idx, init_type);
          c->locals[idx].is_tdz = false;
          if (is_using) {
            if (c->using_stack_local >= 0) {
              emit_get_local(c, c->using_stack_local);
              emit_get_local(c, idx);
              emit_using_push(c, is_await_using);
            } else {
              emit_get_local(c, idx);
              emit_dispose_resource(c, is_await_using);
            }
            emit_op(c, OP_POP);
          }
        }
      } else {
        if (decl->right) {
          compile_expr(c, decl->right);
          compile_destructure_binding(c, target, kind);
          emit_op(c, OP_POP);
        }
      }
    }
  }
}

void compile_destructure_binding(sv_compiler_t *c, sv_ast_t *pat, sv_var_kind_t kind) {
  compile_destructure_pattern(c, pat, false, false, DESTRUCTURE_BIND, kind);
}

static bool fold_static_typeof_compare(
  sv_compiler_t *c, sv_ast_t *cond, bool *out_truth
) {
  if (!cond || cond->type != N_BINARY) return false;
  if (!(cond->op == TOK_SEQ || cond->op == TOK_SNE ||
        cond->op == TOK_EQ  || cond->op == TOK_NE))
    return false;

  sv_ast_t *typeof_node = NULL;
  sv_ast_t *str_node = NULL;
  if (cond->left && cond->left->type == N_TYPEOF &&
      cond->right && cond->right->type == N_STRING) {
    typeof_node = cond->left;
    str_node = cond->right;
  } else if (cond->right && cond->right->type == N_TYPEOF &&
             cond->left && cond->left->type == N_STRING) {
    typeof_node = cond->right;
    str_node = cond->left;
  } else return false;

  if (!typeof_node->right || typeof_node->right->type != N_IDENT) return false;
  sv_ast_t *ident = typeof_node->right;
  int local = resolve_local(c, ident->str, ident->len);
  if (local < 0) return false;
  const char *known = typeof_name_for_type(get_local_inferred_type(c, local));
  if (!known) return false;

  bool is_equal = (strlen(known) == str_node->len &&
                   memcmp(known, str_node->str, str_node->len) == 0);
  bool truth = (cond->op == TOK_SEQ || cond->op == TOK_EQ) ? is_equal : !is_equal;
  *out_truth = truth;
  return true;
}

void compile_if(sv_compiler_t *c, sv_ast_t *node) {
  bool folded_truth = false;
  if (fold_static_typeof_compare(c, node->cond, &folded_truth)) {
    if (folded_truth) compile_stmt(c, node->left);
    else if (node->right) compile_stmt(c, node->right);
    return;
  }

  compile_truthy_test_expr(c, node->cond);
  int else_jump = emit_jump(c, OP_JMP_FALSE);
  compile_stmt(c, node->left);
  if (node->right) {
    int end_jump = emit_jump(c, OP_JMP);
    patch_jump(c, else_jump);
    compile_stmt(c, node->right);
    patch_jump(c, end_jump);
  } else {
    patch_jump(c, else_jump);
  }
}

void compile_while(sv_compiler_t *c, sv_ast_t *node) {
  int loop_start = c->code_len;
  push_loop(c, loop_start, NULL, 0, false);

  compile_truthy_test_expr(c, node->cond);
  int exit_jump = emit_jump(c, OP_JMP_FALSE);
  compile_stmt(c, node->body);

  sv_loop_t *loop = &c->loops[c->loop_count - 1];
  for (int i = 0; i < loop->continues.count; i++)
    patch_jump(c, loop->continues.offsets[i]);

  emit_loop(c, loop_start);
  patch_jump(c, exit_jump);
  pop_loop(c);
}

void compile_do_while(sv_compiler_t *c, sv_ast_t *node) {
  int loop_start = c->code_len;
  push_loop(c, loop_start, NULL, 0, false);
  compile_stmt(c, node->body);

  sv_loop_t *loop = &c->loops[c->loop_count - 1];
  for (int i = 0; i < loop->continues.count; i++)
    patch_jump(c, loop->continues.offsets[i]);

  compile_truthy_test_expr(c, node->cond);
  int exit_jump = emit_jump(c, OP_JMP_FALSE);
  emit_loop(c, loop_start);
  patch_jump(c, exit_jump);
  pop_loop(c);
}

static void for_add_slot_unique(int **slots, int *count, int *cap, int slot) {
  if (slot < 0) return;
  for (int i = 0; i < *count; i++) {
    if ((*slots)[i] == slot) return;
  }
  if (*count >= *cap) {
    int new_cap = (*cap > 0) ? (*cap * 2) : 8;
    int *new_slots = realloc(*slots, (size_t)new_cap * sizeof(int));
    if (!new_slots) return;
    *slots = new_slots;
    *cap = new_cap;
  }
  (*slots)[(*count)++] = slot;
}

static void for_collect_pattern_slots(sv_compiler_t *c, sv_ast_t *pat, int **slots, int *count, int *cap) {
  if (!pat) return;
  switch (pat->type) {
    case N_IDENT: {
      int slot = resolve_local(c, pat->str, pat->len);
      for_add_slot_unique(slots, count, cap, slot);
      break;
    }
    case N_ASSIGN_PAT:
    case N_ASSIGN:
      for_collect_pattern_slots(c, pat->left, slots, count, cap);
      break;
    case N_REST:
    case N_SPREAD:
      for_collect_pattern_slots(c, pat->right, slots, count, cap);
      break;
    case N_ARRAY:
    case N_ARRAY_PAT:
      for (int i = 0; i < pat->args.count; i++)
        for_collect_pattern_slots(c, pat->args.items[i], slots, count, cap);
      break;
    case N_OBJECT:
    case N_OBJECT_PAT:
      for (int i = 0; i < pat->args.count; i++) {
        sv_ast_t *prop = pat->args.items[i];
        if (!prop) continue;
        if (prop->type == N_PROPERTY)
          for_collect_pattern_slots(c, prop->right, slots, count, cap);
        else
          for_collect_pattern_slots(c, prop, slots, count, cap);
      }
      break;
    default:
      break;
  }
}

static void for_collect_var_decl_slots(sv_compiler_t *c, sv_ast_t *init_var, int **slots, int *count, int *cap) {
  if (!init_var || init_var->type != N_VAR) return;
  for (int i = 0; i < init_var->args.count; i++) {
    sv_ast_t *decl = init_var->args.items[i];
    if (!decl || decl->type != N_VARDECL || !decl->left) continue;
    for_collect_pattern_slots(c, decl->left, slots, count, cap);
  }
}

void compile_for(sv_compiler_t *c, sv_ast_t *node) {
  begin_scope(c);

  int *iter_slots = NULL;
  int iter_count = 0;
  int iter_cap = 0;

  if (node->init) {
    if (node->init->type == N_VAR) {
      sv_var_kind_t kind = node->init->var_kind;
      compile_var_decl(c, node->init);
      if (kind == SV_VAR_LET || kind == SV_VAR_CONST)
        for_collect_var_decl_slots(c, node->init, &iter_slots, &iter_count, &iter_cap);
    } else {
      compile_expr(c, node->init);
      emit_op(c, OP_POP);
    }
  }

  int loop_start = c->code_len;
  push_loop(c, loop_start, NULL, 0, false);

  int exit_jump = -1;
  if (node->cond) {
    compile_truthy_test_expr(c, node->cond);
    exit_jump = emit_jump(c, OP_JMP_FALSE);
  }

  int iter_inner_start = -1;
  if (iter_count > 0) {
  begin_scope(c);
  iter_inner_start = c->local_count;
  for (int i = 0; i < iter_count; i++) {
    int outer_idx = iter_slots[i];
    sv_local_t outer = c->locals[outer_idx];
    emit_get_local(c, outer_idx);
    int inner_idx = add_local(c, outer.name, outer.name_len, outer.is_const, c->scope_depth);
    emit_put_local(c, inner_idx);
  }}

  compile_stmt(c, node->body);
  sv_loop_t *loop = &c->loops[c->loop_count - 1];
  for (int i = 0; i < loop->continues.count; i++)
    patch_jump(c, loop->continues.offsets[i]);

  int break_close_slot = -1;
  if (iter_count > 0) {
    for (int i = 0; i < iter_count; i++) {
      int inner_idx = iter_inner_start + i;
      if (!c->locals[inner_idx].captured) continue;
      int slot = local_to_frame_slot(c, inner_idx);
      if (break_close_slot < 0 || slot < break_close_slot)
        break_close_slot = slot;
    }

    for (int i = 0; i < iter_count; i++) {
      emit_get_local(c, iter_inner_start + i);
      emit_put_local(c, iter_slots[i]);
    }
    end_scope(c);
  }

  if (node->update) {
    sv_ast_t *upd = node->update;
    int slot;
    if (upd->type == N_UPDATE && upd->right && upd->right->type == N_IDENT &&
        (slot = resolve_local_slot(c, upd->right->str, upd->right->len)) >= 0) {
      emit_op(c, upd->op == TOK_POSTINC ? OP_INC_LOCAL : OP_DEC_LOCAL);
      emit(c, (uint8_t)slot);
      set_local_inferred_type(c, c->param_locals + slot, SV_TI_UNKNOWN);
    } else {
      compile_expr(c, upd);
      emit_op(c, OP_POP);
    }
  }

  emit_loop(c, loop_start);
  if (exit_jump >= 0) patch_jump(c, exit_jump);

  int skip_break_cleanup = -1;
  if (break_close_slot >= 0)
    skip_break_cleanup = emit_jump(c, OP_JMP);

  pop_loop(c);

  if (break_close_slot >= 0) {
    emit_op(c, OP_CLOSE_UPVAL);
    emit_u16(c, (uint16_t)break_close_slot);
    patch_jump(c, skip_break_cleanup);
  }

  free(iter_slots);
  end_scope(c);
}


static void compile_for_each(sv_compiler_t *c, sv_ast_t *node, bool is_for_of);

void compile_for_in(sv_compiler_t *c, sv_ast_t *node) {
  compile_for_each(c, node, false);
}


void compile_for_of(sv_compiler_t *c, sv_ast_t *node) {
  compile_for_each(c, node, true);
}

static void compile_for_each_assign_target(sv_compiler_t *c, sv_ast_t *lhs) {
  if (!lhs) return;
  if (lhs->type == N_VAR && lhs->args.count > 0) {
    sv_ast_t *decl = lhs->args.items[0];
    sv_ast_t *target = decl->left ? decl->left : decl;
    if (target->type == N_IDENT) {
      int loc = resolve_local(c, target->str, target->len);
      if (loc == -1) {
        bool is_const = (lhs->var_kind == SV_VAR_CONST ||
                         lhs->var_kind == SV_VAR_USING ||
                         lhs->var_kind == SV_VAR_AWAIT_USING);
        loc = add_local(c, target->str, target->len, is_const, c->scope_depth);
      }
      emit_put_local(c, loc);
    } else {
      if (lhs->var_kind == SV_VAR_VAR) {
        compile_lhs_set(c, target, false);
      } else {
        compile_destructure_binding(c, target, lhs->var_kind);
        emit_op(c, OP_POP);
      }
    }
    return;
  }
  if (lhs->type == N_IDENT) {
    emit_set_var(c, lhs->str, lhs->len, false);
    return;
  }
  compile_lhs_set(c, lhs, false);
}

static void compile_using_dispose_target(sv_compiler_t *c, sv_ast_t *lhs) {
  if (!lhs || lhs->type != N_VAR) return;
  bool is_await_using = lhs->var_kind == SV_VAR_AWAIT_USING;
  if (lhs->var_kind != SV_VAR_USING && !is_await_using) return;
  if (lhs->args.count == 0) return;

  sv_ast_t *decl = lhs->args.items[0];
  if (!decl || decl->type != N_VARDECL || !decl->left || decl->left->type != N_IDENT) return;

  emit_get_var(c, decl->left->str, decl->left->len);
  emit_dispose_resource(c, is_await_using);
  emit_op(c, OP_POP);
}

static bool compile_using_push_target(sv_compiler_t *c, sv_ast_t *lhs, int stack_local) {
  if (!lhs || lhs->type != N_VAR) return false;
  bool is_await_using = lhs->var_kind == SV_VAR_AWAIT_USING;
  if (lhs->var_kind != SV_VAR_USING && !is_await_using) return false;
  if (lhs->args.count == 0) return false;

  sv_ast_t *decl = lhs->args.items[0];
  if (!decl || decl->type != N_VARDECL || !decl->left || decl->left->type != N_IDENT) return false;

  emit_get_local(c, stack_local);
  emit_get_var(c, decl->left->str, decl->left->len);
  emit_using_push(c, is_await_using);
  emit_op(c, OP_POP);
  
  return true;
}

static void compile_for_each(sv_compiler_t *c, sv_ast_t *node, bool is_for_of) {
  begin_scope(c);

  int *iter_slots = NULL;
  int iter_count = 0;
  int iter_cap = 0;

  if (node->left && node->left->type == N_VAR &&
      node->left->var_kind != SV_VAR_VAR) {
    bool is_const = 
      (node->left->var_kind == SV_VAR_CONST ||
       node->left->var_kind == SV_VAR_USING ||
       node->left->var_kind == SV_VAR_AWAIT_USING);
    int lb = c->local_count;
    for (int i = 0; i < node->left->args.count; i++) {
      sv_ast_t *decl = node->left->args.items[i];
      if (!decl || decl->type != N_VARDECL || !decl->left) continue;
      hoist_lexical_pattern(c, decl->left, is_const);
    }
    for (int i = lb; i < c->local_count; i++) {
      c->locals[i].is_tdz = true;
      set_local_inferred_type(c, i, SV_TI_UNKNOWN);
      int slot = i - c->param_locals;
      emit_op(c, OP_SET_LOCAL_UNDEF);
      emit_u16(c, (uint16_t)slot);
    }
    for_collect_var_decl_slots(c, node->left, &iter_slots, &iter_count, &iter_cap);
  }

  if (!is_for_of && node->left && node->left->type == N_VAR &&
      node->left->var_kind == SV_VAR_VAR && node->left->args.count > 0) {
    sv_ast_t *decl = node->left->args.items[0];
    if (decl && decl->right) {
      compile_expr(c, decl->right);
      sv_ast_t *target = decl->left ? decl->left : decl;
      if (target->type == N_IDENT) {
        int loc = resolve_local(c, target->str, target->len);
        if (loc == -1)
          loc = add_local(c, target->str, target->len, false, c->scope_depth);
        emit_put_local(c, loc);
      } else {
        compile_lhs_set(c, target, false);
      }
    }
  }

  int iter_local = -1;
  int idx_local = -1;
  int exit_jump = -1;
  int try_jump_for_of = -1;
  int iter_err_local = -1;
  int break_close_slot = -1;
  int iter_inner_start = -1;
  int using_stack_local = -1;

  bool is_for_await = (node->type == N_FOR_AWAIT_OF);
  bool is_using_loop = node->left && node->left->type == N_VAR &&
    (node->left->var_kind == SV_VAR_USING || node->left->var_kind == SV_VAR_AWAIT_USING);
  bool is_await_using_loop = is_using_loop && node->left->var_kind == SV_VAR_AWAIT_USING;
  int old_using_stack = c->using_stack_local;
  bool old_using_async = c->using_stack_async;
  uint8_t iter_hint = 0;
  if (is_for_of && !is_for_await)
    iter_hint = iter_hint_for_type(infer_expr_type(c, node->right));

  if (is_using_loop) {
    emit_empty_disposal_stack(c);
    using_stack_local = add_local(c, "", 0, false, c->scope_depth);
    emit_put_local(c, using_stack_local);
  }

  compile_expr(c, node->right);
  if (is_for_of) {
    emit_op(c, is_for_await ? OP_FOR_AWAIT_OF : OP_FOR_OF);
    iter_err_local = add_local(c, "", 0, false, c->scope_depth);
    try_jump_for_of = emit_jump(c, OP_TRY_PUSH);
    c->try_depth++;
  } else {
    emit_op(c, OP_FOR_IN);  
    iter_local = add_local(c, "", 0, false, c->scope_depth);
    emit_put_local(c, iter_local);

    emit_number(c, 0);
    idx_local = add_local(c, "", 0, false, c->scope_depth);
    emit_put_local(c, idx_local);
  }

  int loop_start = c->code_len;
  push_loop(c, loop_start, NULL, 0, false);

  if (is_using_loop) {
    emit_empty_disposal_stack(c);
    emit_put_local(c, using_stack_local);
  }

  if (is_for_of) {
    if (is_for_await) {
      emit_op(c, OP_AWAIT_ITER_NEXT);
    } else {
      emit_op(c, OP_ITER_NEXT);
      emit(c, iter_hint);
    }
    exit_jump = emit_jump(c, OP_JMP_TRUE);  
  } else {
    emit_get_local(c, idx_local);
    emit_get_local(c, iter_local);
    emit_op(c, OP_GET_LENGTH);
    emit_op(c, OP_LT);
    exit_jump = emit_jump(c, OP_JMP_FALSE);

    emit_get_local(c, iter_local);
    emit_get_local(c, idx_local);
    emit_op(c, OP_GET_ELEM);
  }

  compile_for_each_assign_target(c, node->left);

  if (iter_count > 0) {
    begin_scope(c);
    iter_inner_start = c->local_count;
    for (int i = 0; i < iter_count; i++) {
      int outer_idx = iter_slots[i];
      sv_local_t outer = c->locals[outer_idx];
      emit_get_local(c, outer_idx);
      int inner_idx = add_local(c, outer.name, outer.name_len,
                                outer.is_const, c->scope_depth);
      emit_put_local(c, inner_idx);
    }
  }

  if (is_using_loop) {
    c->using_stack_local = using_stack_local;
    c->using_stack_async = is_await_using_loop;
    push_using_cleanup(c, using_stack_local, c->scope_depth, is_await_using_loop);
    compile_using_push_target(c, node->left, using_stack_local);
  }

  compile_stmt(c, node->body);
  sv_loop_t *loop = &c->loops[c->loop_count - 1];
  for (int i = 0; i < loop->continues.count; i++)
    patch_jump(c, loop->continues.offsets[i]);

  if (is_using_loop) {
    emit_using_dispose_call(c, using_stack_local, -1, is_await_using_loop, false);
    emit_op(c, OP_POP);

    c->using_stack_local = old_using_stack;
    c->using_stack_async = old_using_async;
    pop_using_cleanup(c);
  } else compile_using_dispose_target(c, node->left);

  if (iter_count > 0) {
    for (int i = 0; i < iter_count; i++) {
      int inner_idx = iter_inner_start + i;
      if (!c->locals[inner_idx].captured) continue;
      int slot = local_to_frame_slot(c, inner_idx);
      if (break_close_slot < 0 || slot < break_close_slot)
        break_close_slot = slot;
    }
    end_scope(c);
  }

  if (!is_for_of) {
    emit_get_local(c, idx_local);
    emit_op(c, OP_INC);
    emit_put_local(c, idx_local);
  }

  emit_loop(c, loop_start);
  patch_jump(c, exit_jump);

  if (is_for_of) {
    emit_op(c, OP_POP);
    emit_op(c, OP_TRY_POP);

    int skip_break_cleanup = -1;
    if (break_close_slot >= 0)
      skip_break_cleanup = emit_jump(c, OP_JMP);

    pop_loop(c);
    if (break_close_slot >= 0) {
      emit_op(c, OP_CLOSE_UPVAL);
      emit_u16(c, (uint16_t)break_close_slot);
      patch_jump(c, skip_break_cleanup);
    }
    emit_op(c, OP_TRY_POP);   
    emit_op(c, OP_ITER_CLOSE);
    int end_jump = emit_jump(c, OP_JMP);

    patch_jump(c, try_jump_for_of);
    int catch_tag = emit_jump(c, OP_CATCH);
    emit_put_local(c, iter_err_local);
    
    if (is_using_loop) {
      emit_using_dispose_call(c, using_stack_local, iter_err_local, is_await_using_loop, true);
      emit_put_local(c, iter_err_local);
    }
    
    emit_op(c, OP_ITER_CLOSE);          
    emit_get_local(c, iter_err_local);  
    emit_op(c, OP_THROW);              
    patch_jump(c, catch_tag);

    patch_jump(c, end_jump);
    c->try_depth--;
  } else {
    int skip_break_cleanup = -1;
    if (break_close_slot >= 0)
      skip_break_cleanup = emit_jump(c, OP_JMP);

    pop_loop(c);
    if (break_close_slot >= 0) {
      emit_op(c, OP_CLOSE_UPVAL);
      emit_u16(c, (uint16_t)break_close_slot);
      patch_jump(c, skip_break_cleanup);
    }
  }

  free(iter_slots);
  end_scope(c);
}


static void emit_close_upvals_to_depth(sv_compiler_t *c, int target_depth) {
for (int i = c->local_count - 1; i >= 0; i--) {
  if (c->locals[i].depth <= target_depth) break;
  if (c->locals[i].captured) {
    int frame_slot = local_to_frame_slot(c, i);
    emit_op(c, OP_CLOSE_UPVAL);
    emit_u16(c, (uint16_t)frame_slot);
  }
}}

void compile_break(sv_compiler_t *c, sv_ast_t *node) {
  if (c->loop_count == 0) return;

  int target = c->loop_count - 1;
  if (node->str) for (int i = c->loop_count - 1; i >= 0; i--) if (
    c->loops[i].label &&
    c->loops[i].label_len == node->len &&
    memcmp(c->loops[i].label, node->str, node->len) == 0
  ) { target = i; break;  }

  emit_close_upvals_to_depth(c, c->loops[target].scope_depth);
  emit_using_cleanups_to_depth(c, c->loops[target].scope_depth);
  
  int offset = emit_jump(c, OP_JMP);
  patch_list_add(&c->loops[target].breaks, offset);
}


void compile_continue(sv_compiler_t *c, sv_ast_t *node) {
  for (int i = c->loop_count - 1; i >= 0; i--) if (node->str) {
    if (
      c->loops[i].label &&
      c->loops[i].label_len == node->len &&
      memcmp(c->loops[i].label, node->str, node->len) == 0
    ) {
      emit_close_upvals_to_depth(c, c->loops[i].scope_depth);
      emit_using_cleanups_to_depth(c, c->loops[i].scope_depth);
      patch_list_add(&c->loops[i].continues, emit_jump(c, OP_JMP));
      return;
    }
  } else if (!c->loops[i].is_switch) {
    emit_close_upvals_to_depth(c, c->loops[i].scope_depth);
    emit_using_cleanups_to_depth(c, c->loops[i].scope_depth);
    patch_list_add(&c->loops[i].continues, emit_jump(c, OP_JMP));
    return;
  }
}

static void compile_finally_block(sv_compiler_t *c, sv_ast_t *finally_body) {
  int finally_jump = emit_jump(c, OP_FINALLY);
  compile_stmt(c, finally_body);
  emit_op(c, OP_FINALLY_RET);
  patch_jump(c, finally_jump);
}

static void compile_catch_body(sv_compiler_t *c, sv_ast_t *node) {
  begin_scope(c);
  if (node->catch_param && node->catch_param->type == N_IDENT) {
    int loc = add_local(c, node->catch_param->str, node->catch_param->len, false, c->scope_depth);
    emit_put_local(c, loc);
  } else if (node->catch_param && is_destructure_pattern_node(node->catch_param)) {
    compile_destructure_binding(c, node->catch_param, SV_VAR_LET);
    emit_op(c, OP_POP);
  } else emit_op(c, OP_POP);  
  
  compile_stmt(c, node->catch_body);
  end_scope(c);
}

void compile_try(sv_compiler_t *c, sv_ast_t *node) {
  c->try_depth++;
  int try_jump = emit_jump(c, OP_TRY_PUSH);

  compile_stmt(c, node->body);
  emit_op(c, OP_TRY_POP);

  bool has_catch = (node->catch_body != NULL);
  bool has_finally = (node->finally_body != NULL);

  if (!has_finally) {
    int end_jump = emit_jump(c, OP_JMP);
    patch_jump(c, try_jump);
    int catch_tag = emit_jump(c, OP_CATCH);
    if (has_catch)
      compile_catch_body(c, node);
    else
      emit_op(c, OP_POP);
    patch_jump(c, catch_tag);
    patch_jump(c, end_jump);
    c->try_depth--;
    return;
  }

  int to_finally_from_try = emit_jump(c, OP_JMP);
  int to_finally_from_catch = -1;
  int to_finally_from_throw = -1;

  patch_jump(c, try_jump);

  if (has_catch) {
    int catch_tag = emit_jump(c, OP_CATCH);
    int catch_throw_jump = emit_jump(c, OP_TRY_PUSH);

    compile_catch_body(c, node);
    emit_op(c, OP_TRY_POP);
    to_finally_from_catch = emit_jump(c, OP_JMP);

    patch_jump(c, catch_throw_jump);
    emit_op(c, OP_POP);  
    to_finally_from_throw = emit_jump(c, OP_JMP);

    patch_jump(c, catch_tag);
  } else {
    emit_op(c, OP_POP);  
    to_finally_from_throw = emit_jump(c, OP_JMP);
  }

  patch_jump(c, to_finally_from_try);
  if (to_finally_from_catch >= 0) patch_jump(c, to_finally_from_catch);
  if (to_finally_from_throw >= 0) patch_jump(c, to_finally_from_throw);

  compile_finally_block(c, node->finally_body);

  c->try_depth--;
}


void compile_switch(sv_compiler_t *c, sv_ast_t *node) {
  int case_count = node->args.count;
  int default_case = -1;
  int *match_to_stub = NULL;
  int *stub_to_body = NULL;

  if (case_count > 0) {
    match_to_stub = calloc((size_t)case_count, sizeof(int));
    stub_to_body = calloc((size_t)case_count, sizeof(int));
    for (int i = 0; i < case_count; i++) {
      match_to_stub[i] = -1;
      stub_to_body[i] = -1;
    }
  }

  compile_expr(c, node->cond);  
  begin_scope(c);
  push_loop(c, c->code_len, NULL, 0, true);

  for (int i = 0; i < case_count; i++) {
    sv_ast_t *cas = node->args.items[i];
    if (!cas->left) {
      default_case = i;
      continue;
    }
    emit_op(c, OP_DUP);
    compile_expr(c, cas->left);
    emit_op(c, OP_SEQ);
    match_to_stub[i] = emit_jump(c, OP_JMP_TRUE);
  }

  int miss_jump = emit_jump(c, OP_JMP);
  int default_to_body = -1;
  int miss_to_end = -1;

  for (int i = 0; i < case_count; i++) {
    if (match_to_stub[i] < 0) continue;
    patch_jump(c, match_to_stub[i]);
    emit_op(c, OP_POP);
    stub_to_body[i] = emit_jump(c, OP_JMP);
  }

  patch_jump(c, miss_jump);
  emit_op(c, OP_POP);
  if (default_case >= 0)
    default_to_body = emit_jump(c, OP_JMP);
  else
    miss_to_end = emit_jump(c, OP_JMP);

  for (int i = 0; i < case_count; i++) {
    if (i == default_case && default_to_body >= 0)
      patch_jump(c, default_to_body);
    if (stub_to_body[i] >= 0)
      patch_jump(c, stub_to_body[i]);

    sv_ast_t *cas = node->args.items[i];
    compile_stmts(c, &cas->args);
  }

  if (miss_to_end >= 0)
    patch_jump(c, miss_to_end);

  free(match_to_stub);
  free(stub_to_body);
  pop_loop(c);
  end_scope(c);
}


static inline bool is_loop_node(sv_ast_t *n) {
  return n && 
    (n->type == N_WHILE || n->type == N_DO_WHILE ||
    n->type == N_FOR    || n->type == N_FOR_IN   ||
    n->type == N_FOR_OF || n->type == N_FOR_AWAIT_OF);
}

void compile_label(sv_compiler_t *c, sv_ast_t *node) {
  if (is_loop_node(node->body)) {
    c->pending_label = node->str;
    c->pending_label_len = node->len;
    compile_stmt(c, node->body);
    c->pending_label = NULL;
    c->pending_label_len = 0;
  } else {
    push_loop(c, c->code_len, node->str, node->len, false);
    compile_stmt(c, node->body);
    pop_loop(c);
  }
}


static void emit_field_inits(sv_compiler_t *c, sv_ast_t **fields, int count) {
  sv_compiler_t *enc = c->enclosing;
  for (int i = 0; i < count; i++) {
    sv_ast_t *m = fields[i];
    emit_op(c, OP_THIS);
    if (m->right) compile_expr(c, m->right);
    else emit_op(c, OP_UNDEF);
    if (m->flags & FN_COMPUTED) {
      int key_local = enc->computed_key_locals[i];
      enc->locals[key_local].captured = true;
      uint16_t slot = (uint16_t)local_to_frame_slot(enc, key_local);
      int uv = add_upvalue(c, slot, true, false);
      emit_op(c, OP_GET_UPVAL);
      emit_u16(c, (uint16_t)uv);
    } else {
      compile_static_property_key(c, m->left);
    }
    emit_op(c, OP_SWAP);
    emit_op(c, OP_DEFINE_METHOD_COMP);
    emit(c, 0);
    emit_op(c, OP_POP);
  }
}


static sv_ast_t *find_class_constructor(sv_ast_t *node) {
  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *m = node->args.items[i];
    if (m->type == N_METHOD && m->left && m->left->type == N_IDENT &&
        m->left->len == 11 &&
        memcmp(m->left->str, "constructor", 11) == 0) {
      return m;
    }
  }
  return NULL;
}

static inline bool is_class_method_def(const sv_ast_t *m) {
  return 
    m && m->right && m->right->type == N_FUNC &&
    (m->right->flags & FN_METHOD);
}

static void compile_class_method(
  sv_compiler_t *c, sv_ast_t *m,
  int ctor_local, int proto_local,
  int preeval_key
) {
  bool is_static = !!(m->flags & FN_STATIC);
  int home_local = is_static ? ctor_local : proto_local;
  bool is_fn = is_class_method_def(m);

  if (is_fn) {
    if (is_static) m->right->flags |= FN_STATIC;
    compile_func_expr(c, m->right);   
    emit_get_local(c, home_local);    
    emit_op(c, OP_SET_HOME_OBJ);      
    emit_op(c, OP_SWAP);              
  } else {
    emit_get_local(c, home_local);    
    if (m->right) compile_expr(c, m->right);
    else emit_op(c, OP_UNDEF);        
  }

  uint8_t method_flags = 0;
  if (m->flags & FN_GETTER) method_flags |= 1;
  if (m->flags & FN_SETTER) method_flags |= 2;

  if (m->flags & FN_COMPUTED) {
    if (preeval_key >= 0) emit_get_local(c, preeval_key);
    else compile_expr(c, m->left);
  } else compile_static_property_key(c, m->left); 
  emit_op(c, OP_SWAP);                          
  emit_op(c, OP_DEFINE_METHOD_COMP);
  emit(c, method_flags);                        
  emit_op(c, OP_POP);
}

static inline int compile_class_precompute_key(sv_compiler_t *c, sv_ast_t *key_expr) {
  compile_expr(c, key_expr);
  int loc = add_local(c, "", 0, false, c->scope_depth);
  emit_put_local(c, loc);
  return loc;
}

void compile_class(sv_compiler_t *c, sv_ast_t *node) {
  int outer_name_local = -1;
  bool class_repl_top = is_repl_top_level(c);

  sv_ast_t *ctor_method = NULL;
  bool has_static_name = false;

  int field_count = 0;
  int computed_method_count = 0;

  if (node->str) outer_name_local = resolve_local(c, node->str, node->len);
  if (node->left) compile_expr(c, node->left);
  else emit_op(c, OP_UNDEF);

  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *m = node->args.items[i];
    if (m->type != N_METHOD) continue;
    
    if (
      !(m->flags & FN_STATIC) &&
      !(m->flags & FN_COMPUTED) &&
      m->left && m->left->type == N_IDENT &&
      m->left->len == 11 &&
      memcmp(m->left->str, "constructor", 11) == 0
    ) { ctor_method = m; continue; }
    
    if (
      (m->flags & FN_STATIC) &&
      !(m->flags & FN_COMPUTED) &&
      m->left && m->left->str &&
      m->left->len == 4 &&
      memcmp(m->left->str, "name", 4) == 0
    ) has_static_name = true;
    
    bool is_fn = is_class_method_def(m);
    if (!(m->flags & FN_STATIC) && !is_fn) field_count++;
    if (node->str && (m->flags & FN_COMPUTED) && (is_fn || (m->flags & FN_STATIC))) computed_method_count++;
  }

  sv_ast_t **field_inits = NULL;
  int *computed_key_locals = NULL;
  int *method_comp_keys = NULL;
  if (field_count > 0) {
    field_inits = malloc(sizeof(sv_ast_t *) * field_count);
    computed_key_locals = malloc(sizeof(int) * field_count);
  }
  if (computed_method_count > 0) {
    method_comp_keys = malloc(sizeof(int) * node->args.count);
    for (int i = 0; i < node->args.count; i++) method_comp_keys[i] = -1;
  }

  if (field_count > 0 || method_comp_keys) {
  int fi = 0;
  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *m = node->args.items[i];
    if (m->type != N_METHOD || m == ctor_method) continue;
    
    bool is_fn = is_class_method_def(m);
    bool is_instance_field = !(m->flags & FN_STATIC) && !is_fn;
    
    if (is_instance_field) {
      if (field_inits) field_inits[fi] = m;
      if (computed_key_locals) computed_key_locals[fi] = (m->flags & FN_COMPUTED)
        ? compile_class_precompute_key(c, m->left) : -1;
      fi++;
      continue;
    }
    
    if (!method_comp_keys || !(m->flags & FN_COMPUTED)) continue;
    method_comp_keys[i] = compile_class_precompute_key(c, m->left);
  }}

  int inner_name_local = -1;
  if (node->str) {
    begin_scope(c);
    inner_name_local = add_local(c, node->str, node->len, true, c->scope_depth);
  }

  if (ctor_method && ctor_method->right) {
    c->field_inits = field_inits;
    c->field_init_count = field_count;
    c->computed_key_locals = computed_key_locals;
    compile_func_expr(c, ctor_method->right);
    c->field_inits = NULL;
    c->field_init_count = 0;
    c->computed_key_locals = NULL;
  } else if (field_count > 0) {
    c->computed_key_locals = computed_key_locals;
    sv_compiler_t comp;
    sv_compile_ctx_init_child(&comp, c, NULL, c->mode);

    if (node->left) {
      emit_op(&comp, OP_THIS);
      emit_op(&comp, OP_SPECIAL_OBJ);
      emit(&comp, 2);
      emit_op(&comp, OP_SWAP);
      emit_op(&comp, OP_SPECIAL_OBJ);
      emit(&comp, 0);
      emit_op(&comp, OP_SUPER_APPLY);
      emit_u16(&comp, 1);
      emit_op(&comp, OP_POP);
    }

    emit_field_inits(&comp, field_inits, field_count);
    emit_op(&comp, OP_RETURN_UNDEF);

    sv_func_t *fn = code_arena_bump(sizeof(sv_func_t));
    memset(fn, 0, sizeof(sv_func_t));
    fn->code = code_arena_bump((size_t)comp.code_len);
    memcpy(fn->code, comp.code, (size_t)comp.code_len);
    fn->code_len = comp.code_len;
    sv_func_init_obj_sites(fn);
    if (comp.const_count > 0) {
      fn->constants = code_arena_bump((size_t)comp.const_count * sizeof(ant_value_t));
      memcpy(fn->constants, comp.constants, (size_t)comp.const_count * sizeof(ant_value_t));
      fn->const_count = comp.const_count;
      build_gc_const_tables(fn);
    }
    if (comp.atom_count > 0) {
      fn->atoms = code_arena_bump((size_t)comp.atom_count * sizeof(sv_atom_t));
      memcpy(fn->atoms, comp.atoms, (size_t)comp.atom_count * sizeof(sv_atom_t));
      fn->atom_count = comp.atom_count;
    }
    fn->ic_count = (uint16_t)comp.ic_count;
    if (fn->ic_count > 0) {
      fn->ic_slots = code_arena_bump((size_t)fn->ic_count * sizeof(sv_ic_entry_t));
      memset(fn->ic_slots, 0, (size_t)fn->ic_count * sizeof(sv_ic_entry_t));
    }
    if (comp.upvalue_count > 0) {
      fn->upval_descs = code_arena_bump(
        (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
      memcpy(fn->upval_descs, comp.upval_descs,
             (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
      fn->upvalue_count = comp.upvalue_count;
    }
    fn->max_locals = comp.max_local_count;
    fn->max_stack = fn->max_locals + 64;
    fn->local_type_count = fn->max_locals;
    if (fn->max_locals > 0) {
      fn->local_types = code_arena_bump((size_t)fn->max_locals * sizeof(sv_type_info_t));
      memset(fn->local_types, 0, (size_t)fn->max_locals * sizeof(sv_type_info_t));
      if (comp.slot_types) {
        int ncopy = fn->max_locals < comp.slot_type_cap ? fn->max_locals : comp.slot_type_cap;
        memcpy(fn->local_types, comp.slot_types, (size_t)ncopy * sizeof(sv_type_info_t));
      }
    }
    fn->param_count = comp.param_count;
    fn->is_strict = comp.is_strict;
    fn->filename = c->js->filename;
    fn->source_line = (int)node->line;
    if (node->str && node->len > 0) {
      char *name = code_arena_bump(node->len + 1);
      memcpy(name, node->str, node->len);
      name[node->len] = '\0';
      fn->name = name;
    }
    sv_compile_ctx_cleanup(&comp);
    int idx = add_constant(c, mkval(T_NTARG, (uintptr_t)fn));
    emit_op(c, OP_CLOSURE);
    emit_u32(c, (uint32_t)idx);
  } else emit_op(c, OP_UNDEF);
  
  free(field_inits);
  free(computed_key_locals);
  c->computed_key_locals = NULL;

  if (node->str && !has_static_name) {
    int atom = add_atom(c, node->str, node->len);
    emit_op(c, OP_DEFINE_CLASS);
    emit_u32(c, (uint32_t)atom);
    emit(c, 1);
  } else {
    emit_op(c, OP_DEFINE_CLASS);
    emit_u32(c, 0);
    emit(c, 0);
  }
  
  emit_u32(c, node->src_off);
  emit_u32(c, node->src_end);

  int proto_local = add_local(c, "", 0, false, c->scope_depth);
  int ctor_local = add_local(c, "", 0, false, c->scope_depth);
  emit_put_local(c, proto_local);
  emit_put_local(c, ctor_local);

  if (inner_name_local >= 0) {
    emit_get_local(c, ctor_local);
    emit_put_local(c, inner_name_local);
  }

  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *m = node->args.items[i];
    if (m->type == N_STATIC_BLOCK) {
      begin_scope(c);
      compile_stmts(c, &m->args);
      end_scope(c);
      continue;
    }
    
    if (m->type != N_METHOD) continue;
    if (m == ctor_method) continue;
    
    bool is_fn = is_class_method_def(m);
    if (!is_fn && !(m->flags & FN_STATIC)) continue;
    
    compile_class_method(
      c, m, ctor_local, proto_local, 
      method_comp_keys ? method_comp_keys[i] : -1
    );
  }

  free(method_comp_keys);
  emit_get_local(c, ctor_local);

  if (class_repl_top && node->str) {
    emit_op(c, OP_DUP);
    emit_atom_op(c, OP_PUT_GLOBAL, node->str, node->len);
  } else if (outer_name_local >= 0) {
    emit_op(c, OP_DUP);
    emit_put_local(c, outer_name_local);
    c->locals[outer_name_local].is_tdz = false;
  }

  if (node->str) end_scope(c);
}

static bool ast_contains_await_expr(const sv_ast_t *node) {
  if (!node) return false;
  
  if (node->type == N_AWAIT) return true;
  if (node->type == N_FUNC) return false;

  if (ast_contains_await_expr(node->left))         return true;
  if (ast_contains_await_expr(node->right))        return true;
  if (ast_contains_await_expr(node->cond))         return true;
  if (ast_contains_await_expr(node->body))         return true;
  if (ast_contains_await_expr(node->catch_body))   return true;
  if (ast_contains_await_expr(node->finally_body)) return true;
  if (ast_contains_await_expr(node->catch_param))  return true;
  if (ast_contains_await_expr(node->init))         return true;
  if (ast_contains_await_expr(node->update))       return true;

  for (int i = 0; i < node->args.count; i++) {
    if (ast_contains_await_expr(node->args.items[i])) return true;
  }

  return false;
}

static bool func_params_contain_await(const sv_ast_t *node) {
  if (!node) return false;
  for (int i = 0; i < node->args.count; i++) {
    if (ast_contains_await_expr(node->args.items[i])) return true;
  }
  return false;
}

sv_func_t *compile_function_body(
  sv_compiler_t *enclosing,
  sv_ast_t *node,
  sv_compile_mode_t mode
) {
  if ((node->flags & FN_ASYNC) && func_params_contain_await(node)) {
    js_mkerr_typed(
      enclosing->js, JS_ERR_SYNTAX,
      "await is not allowed in async function parameters");
    return NULL;
  }

  sv_compiler_t comp;
  sv_compile_ctx_init_child(&comp, enclosing, node, mode);

  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *p = node->args.items[i];
    if (p->type == N_IDENT) {
      add_local(&comp, p->str, p->len, false, -1);  
    } else if (p->type == N_REST && p->right && p->right->type == N_IDENT) {
      add_local(&comp, p->right->str, p->right->len, false, -1);
    } else if (p->type == N_ASSIGN_PAT && p->left && p->left->type == N_IDENT) {
      add_local(&comp, p->left->str, p->left->len, false, -1);
    } else add_local(&comp, "", 0, false, -1);
  }

  comp.param_locals = comp.local_count;

  bool has_own_use_strict = false;
  if (node->body && node->body->type == N_BLOCK) for (int i = 0; i < node->body->args.count; i++) {
    sv_ast_t *stmt = node->body->args.items[i];
    if (!stmt || stmt->type == N_EMPTY) continue;
    if (stmt->type != N_STRING) break;
    if (sv_ast_is_use_strict(comp.js, stmt)) {
      has_own_use_strict = true;
      comp.is_strict = true;
    }
  }

  if (comp.is_strict) {
    const char *param_names[256];
    uint32_t param_lens[256];
    int param_name_count = 0;

    for (int i = 0; i < node->args.count; i++) {
      sv_ast_t *p = node->args.items[i];
      const char *pname = NULL;
      uint32_t plen = 0;

      if (p && p->type == N_IDENT) {
        pname = p->str; plen = p->len;
      } else if (p && p->type == N_REST && p->right && p->right->type == N_IDENT) {
        pname = p->right->str; plen = p->right->len;
      } else if (p && p->type == N_ASSIGN_PAT && p->left && p->left->type == N_IDENT) {
        pname = p->left->str; plen = p->left->len;
      }

      if (!pname || plen == 0) continue;

      if (is_strict_restricted_ident(pname, plen)) {
        js_mkerr_typed(
          comp.js, JS_ERR_SYNTAX,
          "strict mode forbids '%.*s' as a parameter name",
          (int)plen, pname);
        return NULL;
      }

      for (int j = 0; j < param_name_count; j++) {
        if (param_lens[j] == plen &&
            memcmp(param_names[j], pname, plen) == 0) {
          js_mkerr_typed(
            comp.js, JS_ERR_SYNTAX,
            "duplicate parameter name '%.*s' in strict mode",
            (int)plen, pname);
          return NULL;
        }
      }

      if (param_name_count < (int)(sizeof(param_names) / sizeof(param_names[0]))) {
        param_names[param_name_count] = pname;
        param_lens[param_name_count] = plen;
        param_name_count++;
      }
    }
  }

  bool has_non_simple_params = false;
  for (int i = 0; i < node->args.count; i++) {
    sv_ast_t *p = node->args.items[i];
    if (p->type != N_IDENT) { has_non_simple_params = true; break; }
  }

  if (has_own_use_strict && has_non_simple_params) {
    js_mkerr_typed(
      comp.js, JS_ERR_SYNTAX,
      "Illegal 'use strict' directive in function with non-simple parameter list");
    return NULL;
  }
  
  bool repl_top = is_repl_top_level(&comp);
  if (!has_non_simple_params && node->body) {
    if (node->body->type == N_BLOCK) {
      if (!repl_top) {
        for (int i = 0; i < node->body->args.count; i++)
          hoist_var_decls(&comp, node->body->args.items[i]);
        hoist_lexical_decls(&comp, &node->body->args);
      }
      hoist_func_decls(&comp, &node->body->args);
    } else if (!repl_top) hoist_var_decls(&comp, node->body);
  }

  if (!has_non_simple_params) {
    for (int i = 0; i < node->args.count; i++) {
      sv_ast_t *p = node->args.items[i];
      if (p->type == N_ASSIGN_PAT) {
        emit_op(&comp, OP_GET_ARG);
        emit_u16(&comp, (uint16_t)i);
        emit_op(&comp, OP_DUP);
        emit_op(&comp, OP_IS_UNDEF);
        int skip = emit_jump(&comp, OP_JMP_FALSE);
        emit_op(&comp, OP_POP);
        compile_expr(&comp, p->right);
        patch_jump(&comp, skip);
        if (p->left && p->left->type == N_IDENT) {
          emit_op(&comp, OP_PUT_ARG);
          emit_u16(&comp, (uint16_t)i);
        } else if (p->left) {
          compile_destructure_binding(&comp, p->left, SV_VAR_LET);
          emit_op(&comp, OP_POP);
        } else emit_op(&comp, OP_POP);
      } else if (
        p->type == N_ARRAY_PAT || p->type == N_ARRAY ||
        p->type == N_OBJECT_PAT || p->type == N_OBJECT) {
        emit_op(&comp, OP_GET_ARG);
        emit_u16(&comp, (uint16_t)i);
        compile_destructure_binding(&comp, p, SV_VAR_LET);
        emit_op(&comp, OP_POP);
      } else if (p->type == N_REST && p->right && p->right->type == N_IDENT) {
        emit_op(&comp, OP_REST);
        emit_u16(&comp, (uint16_t)i);
        int loc = resolve_local(&comp, p->right->str, p->right->len);
        if (loc >= 0) {
          emit_op(&comp, OP_PUT_ARG);
          emit_u16(&comp, (uint16_t)loc);
        }
      } else if (p->type == N_REST && p->right) {
        emit_op(&comp, OP_REST);
        emit_u16(&comp, (uint16_t)i);
        compile_destructure_binding(&comp, p->right, SV_VAR_LET);
        emit_op(&comp, OP_POP);
      }
    }
  } else {
    int *param_bind_locals = NULL;
    int  param_bind_count  = 0;
    int  param_bind_cap    = 0;

    for (int i = 0; i < node->args.count; i++) {
      sv_ast_t *p = node->args.items[i];
      const char *pname = NULL;
      uint32_t    plen  = 0;
      if (p->type == N_IDENT) {
        pname = p->str; plen = p->len;
      } else if ((
        p->type == N_ASSIGN_PAT) && p->left &&
        p->left->type == N_IDENT) {
        pname = p->left->str; plen = p->left->len;
      } else if (
        p->type == N_REST && p->right &&
        p->right->type == N_IDENT) {
        pname = p->right->str; plen = p->right->len;
      }

      int lb = comp.local_count;
      if (pname && plen) {
        int loc = add_local(&comp, pname, plen, false, 0);
        comp.locals[loc].is_tdz = true;
        set_local_inferred_type(&comp, loc, SV_TI_UNKNOWN);
        int slot = loc - comp.param_locals;
        emit_op(&comp, OP_SET_LOCAL_UNDEF);
        emit_u16(&comp, (uint16_t)slot);
      }

      if (param_bind_count >= param_bind_cap) {
        param_bind_cap = param_bind_cap ? param_bind_cap * 2 : 8;
        param_bind_locals = realloc(
          param_bind_locals,
          (size_t)param_bind_cap * sizeof(int));
      }
      param_bind_locals[param_bind_count++] = lb;
    }

    for (int i = 0; i < node->args.count; i++) {
      sv_ast_t *p = node->args.items[i];
      int bind_lb = param_bind_locals[i];

      if (p->type == N_IDENT) {
        if (bind_lb < comp.local_count) {
          emit_op(&comp, OP_GET_ARG);
          emit_u16(&comp, (uint16_t)i);
          int slot = bind_lb - comp.param_locals;
          comp.locals[bind_lb].is_tdz = false;
          if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
          else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
          set_local_inferred_type(&comp, bind_lb, SV_TI_UNKNOWN);
        }
      } else if (p->type == N_ASSIGN_PAT) {
        emit_op(&comp, OP_GET_ARG);
        emit_u16(&comp, (uint16_t)i);
        emit_op(&comp, OP_DUP);
        emit_op(&comp, OP_IS_UNDEF);
        int skip = emit_jump(&comp, OP_JMP_FALSE);
        emit_op(&comp, OP_POP);
        compile_expr(&comp, p->right);
        patch_jump(&comp, skip);
        if (p->left && p->left->type == N_IDENT && bind_lb < comp.local_count) {
          int slot = bind_lb - comp.param_locals;
          comp.locals[bind_lb].is_tdz = false;
          if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
          else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
          set_local_inferred_type(&comp, bind_lb, SV_TI_UNKNOWN);
        } else if (p->left) {
          compile_destructure_binding(&comp, p->left, SV_VAR_LET);
          emit_op(&comp, OP_POP);
        } else {
          emit_op(&comp, OP_POP);
        }
      } else if (
        p->type == N_ARRAY_PAT || p->type == N_ARRAY ||
        p->type == N_OBJECT_PAT || p->type == N_OBJECT) {
        emit_op(&comp, OP_GET_ARG);
        emit_u16(&comp, (uint16_t)i);
        compile_destructure_binding(&comp, p, SV_VAR_LET);
        emit_op(&comp, OP_POP);
      } else if (
        p->type == N_REST && p->right && p->right->type == N_IDENT &&
        bind_lb < comp.local_count) {
        emit_op(&comp, OP_REST);
        emit_u16(&comp, (uint16_t)i);
        int slot = bind_lb - comp.param_locals;
        comp.locals[bind_lb].is_tdz = false;
        if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
        else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
        set_local_inferred_type(&comp, bind_lb, SV_TI_UNKNOWN);
      } else if (p->type == N_REST && p->right) {
        emit_op(&comp, OP_REST);
        emit_u16(&comp, (uint16_t)i);
        compile_destructure_binding(&comp, p->right, SV_VAR_LET);
        emit_op(&comp, OP_POP);
      }
    }

    free(param_bind_locals);
    sv_ast_t *body = node->body;

    if (body && body->type != N_BLOCK) {
      if (!repl_top) hoist_var_decls(&comp, body);
    } else if (body) {
      if (!repl_top) {
        for (int i = 0; i < body->args.count; i++)
          hoist_var_decls(&comp, body->args.items[i]);
        hoist_lexical_decls(&comp, &body->args);
      }
      hoist_func_decls(&comp, &body->args);
    }
  }

  if (!comp.is_arrow && has_implicit_arguments_obj(&comp) && (node->flags & FN_USES_ARGS)) {
    static const char args_name[] = "\x01arguments";
    comp.strict_args_local = add_local(&comp, args_name, sizeof(args_name) - 1, false, comp.scope_depth);
    emit_op(&comp, OP_SPECIAL_OBJ);
    emit(&comp, 0);
    emit_put_local(&comp, comp.strict_args_local);
  }

  if (!comp.is_arrow && comp.enclosing && (node->flags & FN_USES_NEW_TARGET)) {
    static const char nt_name[] = "\x01new.target";
    comp.new_target_local = add_local(&comp, nt_name, sizeof(nt_name) - 1, false, comp.scope_depth);
    emit_op(&comp, OP_SPECIAL_OBJ);
    emit(&comp, 1);
    emit_put_local(&comp, comp.new_target_local);
  }

  if (!comp.is_arrow && comp.enclosing && (node->flags & (FN_METHOD | FN_GETTER | FN_SETTER | FN_STATIC))) {
    static const char sv_name[] = "\x01super";
    comp.super_local = add_local(&comp, sv_name, sizeof(sv_name) - 1, false, comp.scope_depth);
    emit_op(&comp, OP_SPECIAL_OBJ);
    emit(&comp, 2);
    emit_put_local(&comp, comp.super_local);
  }

  if (enclosing->field_init_count > 0) {
    emit_field_inits(&comp, enclosing->field_inits, enclosing->field_init_count);
  }

  bool body_has_await_using = false;
  bool body_has_using = node->body && node->body->type == N_BLOCK &&
    stmt_list_has_using_decl(&node->body->args, &body_has_await_using);
  int body_using_try_jump = -1;
  int body_using_err_local = -1;
  int old_using_stack = comp.using_stack_local;
  bool old_using_async = comp.using_stack_async;

  if (body_has_using) {
    emit_empty_disposal_stack(&comp);
    int body_using_stack = add_local(&comp, "", 0, false, comp.scope_depth);
    emit_put_local(&comp, body_using_stack);
    body_using_err_local = add_local(&comp, "", 0, false, comp.scope_depth);

    comp.using_stack_local = body_using_stack;
    comp.using_stack_async = body_has_await_using;
    push_using_cleanup(&comp, body_using_stack, comp.scope_depth, body_has_await_using);

    comp.try_depth++;
    body_using_try_jump = emit_jump(&comp, OP_TRY_PUSH);
  }

  if (node->body) {
    if (node->body->type == N_BLOCK) {
      int last_expr_idx = -1;
      if (has_completion_value(&comp) && node->body->args.count > 0) {
        sv_ast_t *last = node->body->args.items[node->body->args.count - 1];
        if (sv_ast_can_be_expression_statement(last))
          last_expr_idx = node->body->args.count - 1;
      }
      for (int i = 0; i < node->body->args.count; i++) {
        sv_ast_t *stmt = node->body->args.items[i];
        if (i == last_expr_idx) {
          compile_expr(&comp, stmt);
          emit_return_from_stack(&comp);
        } else compile_stmt(&comp, stmt);
      }
    } else compile_tail_return_expr(&comp, node->body);
  }

  for (int i = 0; i < comp.deferred_export_count; i++) {
    sv_deferred_export_t *e = &comp.deferred_exports[i];
    compile_export_emit(&comp, e->name, e->len);
  }

  if (body_has_using) {
    emit_op(&comp, OP_TRY_POP);
    comp.try_depth--;

    emit_using_dispose_call(&comp, comp.using_stack_local, -1, body_has_await_using, false);
    emit_op(&comp, OP_POP);
    int end_jump = emit_jump(&comp, OP_JMP);

    patch_jump(&comp, body_using_try_jump);
    int catch_tag = emit_jump(&comp, OP_CATCH);
    emit_put_local(&comp, body_using_err_local);
    emit_using_dispose_call(&comp, comp.using_stack_local, body_using_err_local, body_has_await_using, true);
    if (!body_has_await_using) emit_op(&comp, OP_THROW);
    patch_jump(&comp, catch_tag);
    patch_jump(&comp, end_jump);

    pop_using_cleanup(&comp);
    comp.using_stack_local = old_using_stack;
    comp.using_stack_async = old_using_async;
  }
  
  emit_using_cleanups_to_depth(&comp, -1);
  emit_close_upvals(&comp);
  emit_op(&comp, OP_RETURN_UNDEF);

  int max_locals = comp.max_local_count - comp.param_locals;
  sv_func_t *func = code_arena_bump(sizeof(sv_func_t));
  memset(func, 0, sizeof(sv_func_t));

  func->code = code_arena_bump((size_t)comp.code_len);
  memcpy(func->code, comp.code, (size_t)comp.code_len);
  func->code_len = comp.code_len;
  sv_func_init_obj_sites(func);

  if (comp.const_count > 0) {
    func->constants = code_arena_bump((size_t)comp.const_count * sizeof(ant_value_t));
    memcpy(func->constants, comp.constants, (size_t)comp.const_count * sizeof(ant_value_t));
    func->const_count = comp.const_count;
    build_gc_const_tables(func);
  }

  if (comp.atom_count > 0) {
    func->atoms = code_arena_bump((size_t)comp.atom_count * sizeof(sv_atom_t));
    memcpy(func->atoms, comp.atoms, (size_t)comp.atom_count * sizeof(sv_atom_t));
    func->atom_count = comp.atom_count;
  }

  func->ic_count = (uint16_t)comp.ic_count;
  if (func->ic_count > 0) {
    func->ic_slots = code_arena_bump((size_t)func->ic_count * sizeof(sv_ic_entry_t));
    memset(func->ic_slots, 0, (size_t)func->ic_count * sizeof(sv_ic_entry_t));
  }

  if (comp.upvalue_count > 0) {
    func->upval_descs = code_arena_bump(
      (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
    memcpy(func->upval_descs, comp.upval_descs,
      (size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
    func->upvalue_count = comp.upvalue_count;
  }

  if (comp.srcpos_count > 0) {
    func->srcpos = code_arena_bump((size_t)comp.srcpos_count * sizeof(sv_srcpos_t));
    memcpy(func->srcpos, comp.srcpos, (size_t)comp.srcpos_count * sizeof(sv_srcpos_t));
    func->srcpos_count = comp.srcpos_count;
  }

  if (enclosing->source && enclosing->source_len > 0) {
    func->source = enclosing->source;
    func->source_len = (int)enclosing->source_len;
    func->source_start = (int)node->src_off;
    func->source_end   = (node->src_end > node->src_off)
      ? (int)node->src_end : func->source_len;
  }

  func->max_locals = max_locals;
  func->max_stack = max_locals + 64;
  func->local_type_count = max_locals;
  if (max_locals > 0) {
    func->local_types = code_arena_bump((size_t)max_locals * sizeof(sv_type_info_t));
    memset(func->local_types, 0, (size_t)max_locals * sizeof(sv_type_info_t));
    if (comp.slot_types) {
      int ncopy = max_locals < comp.slot_type_cap ? max_locals : comp.slot_type_cap;
      memcpy(func->local_types, comp.slot_types, (size_t)ncopy * sizeof(sv_type_info_t));
    }
  }
  func->param_count = comp.param_count;
  func->is_strict = comp.is_strict;
  func->is_arrow = comp.is_arrow;
  
  func->is_async = !!(node->flags & FN_ASYNC);
  func->has_await = false;
  func->is_generator = !!(node->flags & FN_GENERATOR);
  func->is_method = !!(node->flags & FN_METHOD);
  func->is_static = !!(node->flags & FN_STATIC);
  func->is_tla = comp.is_tla;
  func->filename = enclosing->filename ? enclosing->filename : enclosing->js->filename;
  func->source_line = (int)node->line;
  
  if (node->str && node->len > 0) {
    char *name = code_arena_bump(node->len + 1);
    memcpy(name, node->str, node->len);
    name[node->len] = '\0';
    func->name = name;
  } else if (enclosing->inferred_name && enclosing->inferred_name_len > 0) {
    char *name = code_arena_bump(enclosing->inferred_name_len + 1);
    memcpy(name, enclosing->inferred_name, enclosing->inferred_name_len);
    name[enclosing->inferred_name_len] = '\0';
    func->name = name;
  }

  if (func->is_async || func->is_tla) {
  const uint8_t *ip = func->code;
  const uint8_t *end = func->code + func->code_len;
  while (ip < end) {
    sv_op_t op = (sv_op_t)*ip;
    if (op == OP_AWAIT || op == OP_FOR_AWAIT_OF || op == OP_AWAIT_ITER_NEXT) {
      func->has_await = true;
      break;
    }
    int sz = sv_op_size[op];
    if (sz <= 0) break;
    ip += sz;
  }}

  sv_compile_ctx_cleanup(&comp);
  return func;
}

static const char *sv_op_names[OP__COUNT] = {
#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = #name,
#include "silver/opcode.h"
};

enum {
  SVF_none, SVF_u8, SVF_i8, SVF_u16, SVF_i16, SVF_u32, SVF_i32,
  SVF_atom, SVF_atom_u8, SVF_label, SVF_label8, SVF_loc, SVF_loc8,
  SVF_loc_atom, SVF_arg, SVF_const, SVF_const8, SVF_npop, SVF_var_ref,
};

static const uint8_t sv_op_fmts[OP__COUNT] = {
#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = SVF_##f,
#include "silver/opcode.h"
};

void sv_disasm(ant_t *js, sv_func_t *func, const char *label) {
  const char *fname = func->name ? func->name : "";

  fprintf(stderr, "[generated bytecode for function: %s (%p <SharedFunctionInfo %s>)]\n",
    fname, (void *)func, fname);
  fprintf(stderr, "Bytecode length: %d\n", func->code_len);
  fprintf(stderr, "Parameter count %d\n", func->param_count);
  fprintf(stderr, "Register count %d\n", func->max_locals);
  fprintf(stderr, "Frame size %d\n", func->max_locals * (int)sizeof(ant_value_t));

  int pc = 0;
  while (pc < func->code_len) {
    uint8_t op = func->code[pc];
    const char *name = (op < OP__COUNT) ? sv_op_names[op] : "???";
    uint8_t size = (op < OP__COUNT) ? sv_op_size[op] : 1;
    uint8_t fmt = (op < OP__COUNT) ? sv_op_fmts[op] : SVF_none;

    uint32_t line, col;
    if (sv_lookup_srcpos(func, pc, &line, &col))
      fprintf(stderr, "%5u S> ", line);
    else
      fprintf(stderr, "         ");

    fprintf(stderr, "%p @ %4d : ", (void *)(func->code + pc), pc);

    char hex[32];
    int hlen = 0;
    for (int i = 0; i < size && i < 8; i++)
      hlen += snprintf(hex + hlen, sizeof(hex) - hlen, "%02x ", func->code[pc + i]);
      
    fprintf(stderr, "%-18s", hex);
    fprintf(stderr, "%s", name ? name : "???");

    switch (fmt) {
    case SVF_u8:
      fprintf(stderr, " [%d]", func->code[pc + 1]);
      break;
    case SVF_i8:
      fprintf(stderr, " [%d]", (int8_t)func->code[pc + 1]);
      break;
    case SVF_u16:
      fprintf(stderr, " [%d]", sv_get_u16(func->code + pc + 1));
      break;
    case SVF_i16:
      fprintf(stderr, " [%d]", (int16_t)sv_get_u16(func->code + pc + 1));
      break;
    case SVF_u32:
      fprintf(stderr, " [%d]", (int)sv_get_u32(func->code + pc + 1));
      break;
    case SVF_i32:
      fprintf(stderr, " [%d]", (int32_t)sv_get_u32(func->code + pc + 1));
      break;
    case SVF_atom: {
      uint32_t idx = sv_get_u32(func->code + pc + 1);
      if (idx < (uint32_t)func->atom_count)
        fprintf(stderr, " [%.*s]", (int)func->atoms[idx].len, func->atoms[idx].str);
      else
        fprintf(stderr, " a%u", idx);
      if ((op == OP_GET_GLOBAL || op == OP_GET_GLOBAL_UNDEF ||
           op == OP_GET_FIELD || op == OP_GET_FIELD2 || op == OP_PUT_FIELD) && size >= 7)
        fprintf(stderr, " ic[%u]", sv_get_u16(func->code + pc + 5));
      break;
    }
    case SVF_atom_u8: {
      uint32_t idx = sv_get_u32(func->code + pc + 1);
      uint8_t extra = func->code[pc + 5];
      if (idx < (uint32_t)func->atom_count)
        fprintf(stderr, " [%.*s], [%d]", (int)func->atoms[idx].len, func->atoms[idx].str, extra);
      else
        fprintf(stderr, " a%u, [%d]", idx, extra);
      break;
    }
    case SVF_label: {
      int32_t off = (int32_t)sv_get_u32(func->code + pc + 1);
      fprintf(stderr, " [%d] (%d)", off, pc + size + off);
      break;
    }
    case SVF_label8: {
      int8_t off = (int8_t)func->code[pc + 1];
      fprintf(stderr, " [%d] (%d)", off, pc + size + off);
      break;
    }
    case SVF_loc:
      fprintf(stderr, " r%d", sv_get_u16(func->code + pc + 1));
      break;
    case SVF_loc8:
      fprintf(stderr, " r%d", func->code[pc + 1]);
      break;
    case SVF_loc_atom: {
      uint16_t slot = sv_get_u16(func->code + pc + 1);
      uint32_t aidx = sv_get_u32(func->code + pc + 3);
      fprintf(stderr, " r%d", slot);
      if (aidx < (uint32_t)func->atom_count)
        fprintf(stderr, ", [%.*s]", (int)func->atoms[aidx].len, func->atoms[aidx].str);
      else
        fprintf(stderr, ", a%u", aidx);
      break;
    }
    case SVF_arg:
      fprintf(stderr, " a%d", sv_get_u16(func->code + pc + 1));
      break;
    case SVF_const: {
      uint32_t idx = sv_get_u32(func->code + pc + 1);
      fprintf(stderr, " [%u]", idx);
      break;
    }
    case SVF_const8:
      fprintf(stderr, " [%d]", func->code[pc + 1]);
      break;
    case SVF_npop:
      fprintf(stderr, " %d", sv_get_u16(func->code + pc + 1));
      break;
    case SVF_var_ref:
      fprintf(stderr, " [%d]", sv_get_u16(func->code + pc + 1));
      break;
    default:
      break;
    }

    fprintf(stderr, "\n");
    pc += size;
  }

  fprintf(stderr, "Constant pool (size = %d)\n", func->const_count);
  for (int i = 0; i < func->const_count; i++) {
    ant_value_t v = func->constants[i];
    uint8_t t = vtype(v);
    if (t == T_STR) {
      ant_offset_t slen;
      ant_offset_t soff = vstr(js, v, &slen);
      fprintf(stderr, "           %d: <String[%d]: #%.*s>\n", i, (int)slen, (int)slen, (const char *)(uintptr_t)soff);
    } else if (t == T_NUM) {
      fprintf(stderr, "           %d: <Number [%g]>\n", i, tod(v));
    } else if (t == T_CFUNC) {
      sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(v);
      const char *cname = child->name ? child->name : "";
      fprintf(stderr, "           %d: <SharedFunctionInfo %s>\n", i, cname);
    } else fprintf(stderr, "           %d: <Unknown type=%d>\n", i, t);
  }

  if (func->atom_count > 0) {
    fprintf(stderr, "Atom table (size = %d)\n", func->atom_count);
    for (int i = 0; i < func->atom_count; i++)
      fprintf(stderr, "           %d: <String[%d]: #%.*s>\n",
        i, (int)func->atoms[i].len, (int)func->atoms[i].len, func->atoms[i].str);
  }

  fprintf(stderr, "Handler Table (size = 0)\n");
  fprintf(stderr, "Source Position Table (size = %d)\n", func->srcpos_count);
  fprintf(stderr, "\n");

  for (int i = 0; i < func->const_count; i++) {
  if (vtype(func->constants[i]) == T_NTARG) {
    sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(func->constants[i]);
    char child_label[256];
    snprintf(child_label, sizeof(child_label), "%s/closure[%d]", label, i);
    sv_disasm(js, child, child_label);
  }}
}

sv_func_t *sv_compile(ant_t *js, sv_ast_t *program, sv_compile_mode_t mode, const char *source, ant_offset_t source_len) {
  if (!program || program->type != N_PROGRAM) return NULL;
  if (sv_compile_trace_unlikely) fprintf(
    stderr, "[compile] start kind=program mode=%d len=%u body=%d strict=%d\n",
    (int)mode, (unsigned)source_len,
    program->args.count, (program->flags & FN_PARSE_STRICT) != 0 ? 1 : 0
  );
  
  static const char *k_top_name_script = "<script>";
  static const char *k_top_name_module = "<module>";
  static const char *k_top_name_eval   = "<eval>";
  static const char *k_top_name_repl   = "<repl>";
  const        char *top_name          = k_top_name_script;
  
  switch (mode) {
    case SV_COMPILE_MODULE: top_name = k_top_name_module; break;
    case SV_COMPILE_EVAL:   top_name = k_top_name_eval; break;
    case SV_COMPILE_REPL:   top_name = k_top_name_repl; break;
    case SV_COMPILE_SCRIPT:
    default:                top_name = k_top_name_script; break;
  }

  sv_ast_t top_fn;
  memset(&top_fn, 0, sizeof(top_fn));
  
  top_fn.type = N_FUNC;
  top_fn.line = 1;
  top_fn.str = top_name;
  top_fn.len = (uint32_t)strlen(top_name);
  top_fn.src_off = 0;
  top_fn.src_end = (source_len > 0) ? (uint32_t)source_len : 0;
  top_fn.body = sv_ast_new(N_BLOCK);
  top_fn.body->args = program->args;

  sv_compiler_t root;
  sv_compile_ctx_init_root(
    &root, js, js->filename,
    pin_source_text(source, source_len),
    source_len, mode,
    (program->flags & FN_PARSE_STRICT) != 0,  NULL
  );
  
  root.line_table = sv_compile_ctx_build_line_table(root.source, source_len);
  sv_func_t *func = compile_function_body(&root, &top_fn, mode);
  sv_compile_ctx_free_line_table(root.line_table);
  
  if (sv_compile_trace_unlikely) fprintf(
    stderr, "[compile] end kind=program mode=%d thrown=%d func=%p\n",
    (int)mode, js->thrown_exists ? 1 : 0, (void *)func
  );
  
  if (js->thrown_exists || !func) return NULL;
  return func;
}

sv_func_t *sv_compile_function(ant_t *js, const char *source, size_t len, bool is_async, bool is_generator) {
  if (sv_compile_trace_unlikely) fprintf(
    stderr, "[compile] start kind=function len=%u async=%d generator=%d\n",
    (unsigned)len, is_async ? 1 : 0, is_generator ? 1 : 0
  );
  
  const char *prefix = is_async
    ? (is_generator ? "(async function*" : "(async function")
    : (is_generator ? "(function*" : "(function");
    
  size_t prefix_len = strlen(prefix);
  size_t wrapped_len = prefix_len + len + 1;

  char *wrapped = malloc(wrapped_len + 1);
  if (!wrapped) return NULL;

  memcpy(wrapped, prefix, prefix_len);
  memcpy(wrapped + prefix_len, source, len);
  wrapped[prefix_len + len] = ')';
  wrapped[wrapped_len] = '\0';
  
  bool parse_strict = sv_vm_is_strict(js->vm);
  sv_ast_t *program = sv_parse(js, wrapped, (ant_offset_t)wrapped_len, parse_strict);
  if (!program) { free(wrapped); return NULL; }

  sv_ast_t *func_node = NULL;
  if (program->args.count > 0) {
    sv_ast_t *stmt = program->args.items[0];
    if (stmt && stmt->type == N_FUNC)  func_node = stmt;
    else if (stmt && stmt->left && stmt->left->type == N_FUNC) func_node = stmt->left;
  }

  if (!func_node) { free(wrapped); return NULL; }

  sv_compiler_t root;
  sv_compile_ctx_init_root(
    &root, js, js->filename,
    pin_source_text(wrapped, (ant_offset_t)wrapped_len),
    (ant_offset_t)wrapped_len, SV_COMPILE_SCRIPT,
    (program->flags & FN_PARSE_STRICT) != 0, NULL
  );
  
  root.line_table = sv_compile_ctx_build_line_table(root.source, (ant_offset_t)wrapped_len);
  sv_func_t *func = compile_function_body(&root, func_node, SV_COMPILE_SCRIPT);
  sv_compile_ctx_free_line_table(root.line_table);
  free(wrapped);

  if (sv_compile_trace_unlikely) fprintf(
    stderr, "[compile] end kind=function thrown=%d func=%p\n",
    js->thrown_exists ? 1 : 0, (void *)func
  );
    
  if (js->thrown_exists || !func) return NULL;
  return func;
}

sv_func_t *sv_compile_function_with_params(
  ant_t *js,
  const sv_param_t *params,
  int param_count,
  const char *body,
  size_t body_len,
  bool is_async
) {
  if (sv_compile_trace_unlikely) fprintf(
    stderr, "[compile] start kind=function-with-params len=%u params=%d async=%d\n",
    (unsigned)body_len, param_count, is_async ? 1 : 0
  );

  if (!body) {
    body = "";
    body_len = 0;
  }

  bool parse_strict = sv_vm_is_strict(js->vm);
  sv_ast_t *program = sv_parse(js, body, (ant_offset_t)body_len, parse_strict);
  if (!program) return NULL;

  static const char *k_top_name_function = "<function>";
  static const char *k_top_name_async_function = "<async function>";
  const char *top_name = is_async ? k_top_name_async_function : k_top_name_function;

  sv_ast_t top_fn;
  memset(&top_fn, 0, sizeof(top_fn));

  top_fn.type = N_FUNC;
  top_fn.line = 1;
  top_fn.str = top_name;
  top_fn.len = (uint32_t)strlen(top_name);
  top_fn.src_off = 0;
  top_fn.src_end = (body_len > 0) ? (uint32_t)body_len : 0;
  if (is_async) top_fn.flags |= FN_ASYNC;

  for (int i = 0; i < param_count; i++) {
    const char *name = (params && params[i].name) ? params[i].name : "";
    size_t name_len = 0;
    if (params && params[i].name) {
      name_len = params[i].len ? params[i].len : strlen(name);
    }

    sv_ast_t *ident = sv_ast_new(N_IDENT);
    if (!ident) return NULL;

    ident->str = name;
    ident->len = (uint32_t)name_len;
    ident->line = 1;
    ident->col = 1;
    sv_ast_list_push(&top_fn.args, ident);
  }

  top_fn.body = sv_ast_new(N_BLOCK);
  if (!top_fn.body) return NULL;
  top_fn.body->args = program->args;

  sv_compiler_t root;
  sv_compile_ctx_init_root(
    &root, js, js->filename,
    pin_source_text(body, (ant_offset_t)body_len),
    (ant_offset_t)body_len, SV_COMPILE_SCRIPT,
    (program->flags & FN_PARSE_STRICT) != 0, NULL
  );
  
  root.line_table = sv_compile_ctx_build_line_table(root.source, (ant_offset_t)body_len);
  sv_func_t *func = compile_function_body(&root, &top_fn, SV_COMPILE_SCRIPT);
  sv_compile_ctx_free_line_table(root.line_table);
  
  if (sv_compile_trace_unlikely) fprintf(
    stderr, "[compile] end kind=function-with-params thrown=%d func=%p\n",
    js->thrown_exists ? 1 : 0, (void *)func
  );
  
  if (js->thrown_exists || !func) return NULL;
  return func;
}