//! `WasmModuleEmitter::compile`: the single giant orchestration method that
//! drives every other helper to produce the final WASM binary + async-JS glue.
//!
//! Pure code-movement from `mod.rs`. Behaviour is unchanged.
use super::*;
impl WasmModuleEmitter {
pub(super) fn compile(
&mut self,
modules: &[(String, perry_hir::ir::Module)],
) -> WasmCompileOutput {
let classes: BTreeMap<&str, &perry_hir::ir::Class> = modules
.iter()
.flat_map(|(_, module)| &module.classes)
.map(|class| (class.name.as_str(), class))
.collect();
// First pass: collect all string literals
for (_, module) in modules {
self.collect_strings(module);
}
// Register runtime import types and get type indices
// All imports use f64 for JSValues
let t_void = self.get_type_idx(vec![], vec![]);
let t_i32_i32_void = self.get_type_idx(vec![ValType::I32, ValType::I32], vec![]);
let t_f64_void = self.get_type_idx(vec![ValType::I64], vec![]);
let t_f64_f64_f64 = self.get_type_idx(vec![ValType::I64, ValType::I64], vec![ValType::I64]);
let t_f64_f64_i32 = self.get_type_idx(vec![ValType::I64, ValType::I64], vec![ValType::I32]);
let t_f64_f64 = self.get_type_idx(vec![ValType::I64], vec![ValType::I64]);
let t_f64_i32 = self.get_type_idx(vec![ValType::I64], vec![ValType::I32]);
let t_void_f64 = self.get_type_idx(vec![], vec![ValType::I64]);
// Add runtime imports (order matters — defines function indices)
let mut import_idx: u32 = 0;
let mut next_import = || {
let i = import_idx;
import_idx += 1;
i
};
// Additional type signatures needed for Phase 1+
let t_f64_f64_void = self.get_type_idx(vec![ValType::I64, ValType::I64], vec![]);
let t_f64_f64_f64_void =
self.get_type_idx(vec![ValType::I64, ValType::I64, ValType::I64], vec![]);
let t_f64_f64_f64_f64 = self.get_type_idx(
vec![ValType::I64, ValType::I64, ValType::I64],
vec![ValType::I64],
);
let t_f64_f64_f64_f64_f64 = self.get_type_idx(
vec![ValType::I64, ValType::I64, ValType::I64, ValType::I64],
vec![ValType::I64],
);
let rt = RuntimeImports {
string_new: next_import(),
console_log: next_import(),
console_warn: next_import(),
console_error: next_import(),
string_concat: next_import(),
js_add: next_import(),
string_eq: next_import(),
string_len: next_import(),
jsvalue_to_string: next_import(),
jsvalue_to_template_string: next_import(),
is_truthy: next_import(),
js_strict_eq: next_import(),
math_floor: next_import(),
math_ceil: next_import(),
math_round: next_import(),
math_abs: next_import(),
math_sqrt: next_import(),
math_pow: next_import(),
math_random: next_import(),
math_log: next_import(),
date_now: next_import(),
js_typeof: next_import(),
math_min: next_import(),
math_max: next_import(),
parse_int: next_import(),
parse_float: next_import(),
// Phase 0
js_mod: next_import(),
is_null_or_undefined: next_import(),
// Phase 1: Objects
object_new: next_import(),
object_set: next_import(),
object_get: next_import(),
object_get_dynamic: next_import(),
object_set_dynamic: next_import(),
object_delete: next_import(),
object_delete_dynamic: next_import(),
object_keys: next_import(),
object_values: next_import(),
object_entries: next_import(),
object_has_property: next_import(),
object_assign: next_import(),
// Phase 1: Arrays
array_new: next_import(),
array_push: next_import(),
array_pop: next_import(),
array_get: next_import(),
array_set: next_import(),
array_length: next_import(),
array_slice: next_import(),
array_splice: next_import(),
array_shift: next_import(),
array_unshift: next_import(),
array_join: next_import(),
array_index_of: next_import(),
array_includes: next_import(),
array_concat: next_import(),
array_reverse: next_import(),
array_flat: next_import(),
array_is_array: next_import(),
array_from: next_import(),
array_push_spread: next_import(),
// Phase 1: Strings
string_char_at: next_import(),
string_substring: next_import(),
string_index_of: next_import(),
string_slice: next_import(),
string_to_lower_case: next_import(),
string_to_upper_case: next_import(),
string_trim: next_import(),
string_includes: next_import(),
string_starts_with: next_import(),
string_ends_with: next_import(),
string_replace: next_import(),
string_split: next_import(),
string_from_char_code: next_import(),
string_pad_start: next_import(),
string_pad_end: next_import(),
string_repeat: next_import(),
string_match: next_import(),
math_log2: next_import(),
math_log10: next_import(),
// Phase 2: Closures
closure_new: next_import(),
closure_set_capture: next_import(),
closure_call_0: next_import(),
closure_call_1: next_import(),
closure_call_2: next_import(),
closure_call_3: next_import(),
closure_call_spread: next_import(),
// Phase 2: Array higher-order
array_map: next_import(),
array_filter: next_import(),
array_for_each: next_import(),
array_reduce: next_import(),
array_find: next_import(),
array_find_index: next_import(),
array_sort: next_import(),
array_some: next_import(),
array_every: next_import(),
// Phase 3: Classes
class_new: next_import(),
class_set_method: next_import(),
class_call_method: next_import(),
class_get_field: next_import(),
class_set_field: next_import(),
class_set_static: next_import(),
class_get_static: next_import(),
class_instanceof: next_import(),
// Phase 4: JSON
json_parse: next_import(),
json_stringify: next_import(),
// Phase 4: Map
map_new: next_import(),
map_set: next_import(),
map_get: next_import(),
map_has: next_import(),
map_delete: next_import(),
map_size: next_import(),
map_clear: next_import(),
map_entries: next_import(),
map_keys: next_import(),
map_values: next_import(),
// Phase 4: Set
set_new: next_import(),
set_new_from_array: next_import(),
set_add: next_import(),
set_has: next_import(),
set_delete: next_import(),
set_size: next_import(),
set_clear: next_import(),
set_values: next_import(),
// Phase 4: Date
date_new: next_import(),
date_get_time: next_import(),
date_to_iso_string: next_import(),
date_get_full_year: next_import(),
date_get_month: next_import(),
date_get_date: next_import(),
date_get_day: next_import(),
date_get_hours: next_import(),
date_get_minutes: next_import(),
date_get_seconds: next_import(),
date_get_milliseconds: next_import(),
// Phase 4: Error
error_new: next_import(),
error_message: next_import(),
// Phase 4: RegExp
regexp_new: next_import(),
regexp_test: next_import(),
// Phase 4: Globals
number_coerce: next_import(),
is_nan: next_import(),
is_finite: next_import(),
// Phase 5: Misc
console_log_multi: next_import(),
// Phase 1 addition: Class inheritance
class_set_parent: next_import(),
// Phase 3: Try/Catch
try_start: next_import(),
try_end: next_import(),
throw_value: next_import(),
has_exception: next_import(),
get_exception: next_import(),
// Phase 4: URL
url_parse: next_import(),
url_get_href: next_import(),
url_get_pathname: next_import(),
url_get_hostname: next_import(),
url_get_port: next_import(),
url_get_search: next_import(),
url_get_hash: next_import(),
url_get_origin: next_import(),
url_get_protocol: next_import(),
url_get_search_params: next_import(),
searchparams_get: next_import(),
searchparams_has: next_import(),
searchparams_set: next_import(),
searchparams_append: next_import(),
searchparams_delete: next_import(),
searchparams_to_string: next_import(),
// Phase 4: Crypto
crypto_random_uuid: next_import(),
crypto_random_bytes: next_import(),
// Phase 4: Path
path_join: next_import(),
path_dirname: next_import(),
path_basename: next_import(),
path_extname: next_import(),
path_resolve: next_import(),
// Phase 4: Process/OS
os_platform: next_import(),
process_argv: next_import(),
process_cwd: next_import(),
// Phase 6: Buffer
buffer_alloc: next_import(),
buffer_from_string: next_import(),
buffer_to_string: next_import(),
buffer_get: next_import(),
buffer_set: next_import(),
buffer_length: next_import(),
buffer_slice: next_import(),
buffer_concat: next_import(),
uint8array_new: next_import(),
uint8array_from: next_import(),
uint8array_length: next_import(),
uint8array_get: next_import(),
uint8array_set: next_import(),
// Timers
set_timeout: next_import(),
set_interval: next_import(),
clear_timeout: next_import(),
clear_interval: next_import(),
// Response properties
response_status: next_import(),
response_ok: next_import(),
response_headers_get: next_import(),
response_url: next_import(),
// Buffer extras
buffer_copy: next_import(),
buffer_write: next_import(),
buffer_equals: next_import(),
buffer_is_buffer: next_import(),
buffer_byte_length: next_import(),
// Crypto extras
crypto_sha256: next_import(),
crypto_md5: next_import(),
// Path extras
path_is_absolute: next_import(),
// Phase 5: Async/Promise/Fetch
fetch_url: next_import(),
fetch_with_options: next_import(),
response_json: next_import(),
response_text: next_import(),
promise_new: next_import(),
promise_resolve: next_import(),
promise_then: next_import(),
await_promise: next_import(),
// Memory-based bridge (Firefox NaN canonicalization workaround)
mem_call: next_import(),
mem_call_i32: next_import(),
};
self.num_imports = import_idx;
self.rt = Some(rt);
// Additional types for new phases
let t_void_i32 = self.get_type_idx(vec![], vec![ValType::I32]);
// Build import tables dynamically from struct fields
// Each entry: (name, type_idx)
let import_entries: Vec<(&str, u32)> = vec![
("string_new", t_i32_i32_void),
("console_log", t_f64_void),
("console_warn", t_f64_void),
("console_error", t_f64_void),
("string_concat", t_f64_f64_f64),
("js_add", t_f64_f64_f64),
("string_eq", t_f64_f64_i32),
("string_len", t_f64_f64),
("jsvalue_to_string", t_f64_f64),
("jsvalue_to_template_string", t_f64_f64),
("is_truthy", t_f64_i32),
("js_strict_eq", t_f64_f64_i32),
("math_floor", t_f64_f64),
("math_ceil", t_f64_f64),
("math_round", t_f64_f64),
("math_abs", t_f64_f64),
("math_sqrt", t_f64_f64),
("math_pow", t_f64_f64_f64),
("math_random", t_void_f64),
("math_log", t_f64_f64),
("date_now", t_void_f64),
("js_typeof", t_f64_f64),
("math_min", t_f64_f64_f64),
("math_max", t_f64_f64_f64),
("parse_int", t_f64_f64),
("parse_float", t_f64_f64),
// Phase 0
("js_mod", t_f64_f64_f64),
("is_null_or_undefined", t_f64_i32),
// Phase 1: Objects (f64 handles)
("object_new", t_void_f64), // () -> handle
("object_set", t_f64_f64_f64_f64), // (handle, key_str, value) -> handle (chaining)
("object_get", t_f64_f64_f64), // (handle, key_str) -> value
("object_get_dynamic", t_f64_f64_f64), // (handle, key) -> value
("object_set_dynamic", t_f64_f64_f64_void), // (handle, key, value) -> void
("object_delete", t_f64_f64_void), // (handle, key_str) -> void
("object_delete_dynamic", t_f64_f64_void), // (handle, key) -> void
("object_keys", t_f64_f64), // (handle) -> array_handle
("object_values", t_f64_f64), // (handle) -> array_handle
("object_entries", t_f64_f64), // (handle) -> array_handle
("object_has_property", t_f64_f64_i32), // (handle, key) -> i32
("object_assign", t_f64_f64_f64), // (target, source) -> target
// Phase 1: Arrays
("array_new", t_void_f64), // () -> handle
("array_push", t_f64_f64_f64), // (handle, value) -> handle (chaining)
("array_pop", t_f64_f64), // (handle) -> value
("array_get", t_f64_f64_f64), // (handle, index) -> value
("array_set", t_f64_f64_f64_void), // (handle, index, value) -> void
("array_length", t_f64_f64), // (handle) -> length
("array_slice", t_f64_f64_f64_f64), // (handle, start, end) -> new_handle
("array_splice", t_f64_f64_f64_f64), // (handle, start, deleteCount) -> removed_handle
("array_shift", t_f64_f64), // (handle) -> value
("array_unshift", t_f64_f64_void), // (handle, value) -> void
("array_join", t_f64_f64_f64), // (handle, separator) -> string
("array_index_of", t_f64_f64_f64), // (handle, value) -> index
("array_includes", t_f64_f64_i32), // (handle, value) -> i32
("array_concat", t_f64_f64_f64), // (handle1, handle2) -> new_handle
("array_reverse", t_f64_f64), // (handle) -> handle
("array_flat", t_f64_f64), // (handle) -> new_handle
("array_is_array", t_f64_i32), // (value) -> i32
("array_from", t_f64_f64), // (value) -> handle
("array_push_spread", t_f64_f64_f64), // (target, source) -> handle (chaining)
// Phase 1: Strings
("string_charAt", t_f64_f64_f64), // (str, idx) -> str
("string_substring", t_f64_f64_f64_f64), // (str, start, end) -> str
("string_indexOf", t_f64_f64_f64), // (str, search) -> number
("string_slice", t_f64_f64_f64_f64), // (str, start, end) -> str
("string_toLowerCase", t_f64_f64),
("string_toUpperCase", t_f64_f64),
("string_trim", t_f64_f64),
("string_includes", t_f64_f64_i32),
("string_startsWith", t_f64_f64_i32),
("string_endsWith", t_f64_f64_i32),
("string_replace", t_f64_f64_f64_f64), // (str, pat, repl) -> str
("string_split", t_f64_f64_f64), // (str, delim) -> array_handle
("string_fromCharCode", t_f64_f64), // (code) -> str
("string_padStart", t_f64_f64_f64_f64), // (str, len, fill) -> str
("string_padEnd", t_f64_f64_f64_f64),
("string_repeat", t_f64_f64_f64), // (str, count) -> str
("string_match", t_f64_f64_f64), // (str, regex) -> array_handle
("math_log2", t_f64_f64),
("math_log10", t_f64_f64),
// Phase 2: Closures
("closure_new", t_f64_f64_f64), // (func_table_idx, capture_count) -> handle
("closure_set_capture", t_f64_f64_f64_f64), // (handle, idx, value) -> handle (chaining)
("closure_call_0", t_f64_f64), // (handle) -> result
("closure_call_1", t_f64_f64_f64), // (handle, arg0) -> result
("closure_call_2", t_f64_f64_f64_f64), // (handle, arg0, arg1) -> result
("closure_call_3", t_f64_f64_f64_f64_f64), // (handle, arg0, arg1, arg2) -> result
("closure_call_spread", t_f64_f64_f64), // (handle, args_array) -> result
// Phase 2: Array higher-order
("array_map", t_f64_f64_f64), // (handle, closure) -> new_handle
("array_filter", t_f64_f64_f64),
("array_forEach", t_f64_f64_void), // (handle, closure) -> void
("array_reduce", t_f64_f64_f64_f64), // (handle, closure, initial) -> value
("array_find", t_f64_f64_f64), // (handle, closure) -> value
("array_find_index", t_f64_f64_f64), // (handle, closure) -> number
("array_sort", t_f64_f64_f64), // (handle, closure) -> handle
("array_some", t_f64_f64_i32), // (handle, closure) -> i32
("array_every", t_f64_f64_i32), // (handle, closure) -> i32
// Phase 3: Classes
("class_new", t_f64_f64_f64), // (class_id, field_count) -> handle
("class_set_method", t_f64_f64_f64_void), // (class_id, name_str, func_table_idx) -> void
("class_call_method", t_f64_f64_f64_f64), // (handle, name_str, args_array) -> result
("class_get_field", t_f64_f64_f64), // (handle, name_str) -> value
("class_set_field", t_f64_f64_f64_void), // (handle, name_str, value) -> void
("class_set_static", t_f64_f64_f64_void), // (class_id, name_str, value) -> void
("class_get_static", t_f64_f64_f64), // (class_id, name_str) -> value
("class_instanceof", t_f64_f64_i32), // (handle, class_id) -> i32
// Phase 4: JSON
("json_parse", t_f64_f64), // (str) -> handle
("json_stringify", t_f64_f64), // (value) -> str
// Phase 4: Map
("map_new", t_void_f64),
("map_set", t_f64_f64_f64_void), // (handle, key, value) -> void
("map_get", t_f64_f64_f64),
("map_has", t_f64_f64_i32),
("map_delete", t_f64_f64_void),
("map_size", t_f64_f64),
("map_clear", t_f64_void),
("map_entries", t_f64_f64),
("map_keys", t_f64_f64),
("map_values", t_f64_f64),
// Phase 4: Set
("set_new", t_void_f64),
("set_new_from_array", t_f64_f64),
("set_add", t_f64_f64_void),
("set_has", t_f64_f64_i32),
("set_delete", t_f64_f64_void),
("set_size", t_f64_f64),
("set_clear", t_f64_void),
("set_values", t_f64_f64),
// Phase 4: Date
("date_new_val", t_f64_f64), // (opt_arg) -> handle
("date_get_time", t_f64_f64),
("date_to_iso_string", t_f64_f64),
("date_get_full_year", t_f64_f64),
("date_get_month", t_f64_f64),
("date_get_date", t_f64_f64),
("date_get_day", t_f64_f64),
("date_get_hours", t_f64_f64),
("date_get_minutes", t_f64_f64),
("date_get_seconds", t_f64_f64),
("date_get_milliseconds", t_f64_f64),
// Phase 4: Error
("error_new", t_f64_f64), // (message) -> handle
("error_message", t_f64_f64), // (handle) -> string
// Phase 4: RegExp
("regexp_new", t_f64_f64_f64), // (pattern, flags) -> handle
("regexp_test", t_f64_f64_i32), // (regex, str) -> i32
// Phase 4: Globals
("number_coerce", t_f64_f64),
("is_nan", t_f64_i32),
("is_finite", t_f64_i32),
// Phase 5
("console_log_multi", t_f64_void), // (args_array) -> void
// Phase 1 addition: Class inheritance
("class_set_parent", t_f64_f64_void), // (child_str, parent_str) -> void
// Phase 3: Try/Catch
("try_start", t_void), // () -> void
("try_end", t_void), // () -> void
("throw_value", t_f64_void), // (val) -> void
("has_exception", t_void_i32), // () -> i32
("get_exception", t_void_f64), // () -> f64
// Phase 4: URL
("url_parse", t_f64_f64), // (url_str) -> handle
("url_get_href", t_f64_f64),
("url_get_pathname", t_f64_f64),
("url_get_hostname", t_f64_f64),
("url_get_port", t_f64_f64),
("url_get_search", t_f64_f64),
("url_get_hash", t_f64_f64),
("url_get_origin", t_f64_f64),
("url_get_protocol", t_f64_f64),
("url_get_search_params", t_f64_f64),
("searchparams_get", t_f64_f64_f64), // (handle, key) -> str
("searchparams_has", t_f64_f64_i32), // (handle, key) -> i32
("searchparams_set", t_f64_f64_f64_void), // (handle, key, val) -> void
("searchparams_append", t_f64_f64_f64_void),
("searchparams_delete", t_f64_f64_void),
("searchparams_to_string", t_f64_f64),
// Phase 4: Crypto
("crypto_random_uuid", t_void_f64),
("crypto_random_bytes", t_f64_f64),
// Phase 4: Path
("path_join", t_f64_f64_f64), // (a, b) -> str
("path_dirname", t_f64_f64),
("path_basename", t_f64_f64),
("path_extname", t_f64_f64),
("path_resolve", t_f64_f64),
// Phase 4: Process/OS
("os_platform", t_void_f64),
("process_argv", t_void_f64),
("process_cwd", t_void_f64),
// Phase 6: Buffer
("buffer_alloc", t_f64_f64),
("buffer_from_string", t_f64_f64_f64),
("buffer_to_string", t_f64_f64_f64),
("buffer_get", t_f64_f64_f64),
("buffer_set", t_f64_f64_f64_void),
("buffer_length", t_f64_f64),
("buffer_slice", t_f64_f64_f64_f64),
("buffer_concat", t_f64_f64),
("uint8array_new", t_f64_f64),
("uint8array_from", t_f64_f64),
("uint8array_length", t_f64_f64),
("uint8array_get", t_f64_f64_f64),
("uint8array_set", t_f64_f64_f64_void),
// Timers
("set_timeout", t_f64_f64_f64), // (closure, delay) -> timer_id
("set_interval", t_f64_f64_f64), // (closure, delay) -> timer_id
("clear_timeout", t_f64_void), // (id) -> void
("clear_interval", t_f64_void), // (id) -> void
// Response properties
("response_status", t_f64_f64), // (handle) -> number
("response_ok", t_f64_i32), // (handle) -> i32
("response_headers_get", t_f64_f64_f64), // (handle, name) -> str
("response_url", t_f64_f64), // (handle) -> str
// Buffer extras
("buffer_copy", {
self.get_type_idx(vec![ValType::I64; 5], vec![ValType::I64])
}),
("buffer_write", t_f64_f64_f64_f64), // (handle, str, offset, encoding) -> number
("buffer_equals", t_f64_f64_i32), // (handle, other) -> i32
("buffer_is_buffer", t_f64_i32), // (val) -> i32
("buffer_byte_length", t_f64_f64), // (val) -> number
// Crypto extras
("crypto_sha256", t_f64_f64), // (data) -> promise_handle
("crypto_md5", t_f64_f64), // (data) -> undefined
// Path extras
("path_is_absolute", t_f64_i32), // (str) -> i32
// Phase 5: Async/Promise/Fetch
("fetch_url", t_f64_f64), // (url_str) -> promise_handle
("fetch_with_options", t_f64_f64_f64_f64_f64), // (url, method, body, headers_obj, redirect) -> promise_handle
("response_json", t_f64_f64), // (response_handle) -> promise_handle
("response_text", t_f64_f64), // (response_handle) -> promise_handle
("promise_new", t_void_f64), // () -> promise_handle
("promise_resolve", t_f64_f64_void), // (promise_handle, value) -> void
("promise_then", t_f64_f64_f64), // (promise_handle, closure_handle) -> promise_handle
("await_promise", t_f64_f64), // (value) -> resolved_value_or_value
// Memory-based bridge: args written to WASM memory at 0xFF00, only plain numbers as params
("mem_call", {
self.get_type_idx(
vec![ValType::F64, ValType::F64, ValType::I32],
vec![ValType::F64],
)
}), // (func_name_id, arg_count, base_addr) -> f64 dummy
("mem_call_i32", {
self.get_type_idx(
vec![ValType::F64, ValType::F64, ValType::I32],
vec![ValType::I32],
)
}), // (func_name_id, arg_count, base_addr) -> i32
];
// Collect all closures from all modules (they need function indices too).
// Track the module index so closures can be associated with their parent module's func_map.
let mut closure_funcs: Vec<(
FuncId,
Vec,
Vec,
Vec,
Vec,
usize,
)> = Vec::new();
// The class whose constructor, instance method, accessor or field initializer
// holds an arrow: `super` inside it resolves from that class. Any other closure
// (an object literal's method) has its own home object.
let mut closure_class: std::collections::HashMap<(usize, FuncId), String> =
Default::default();
for (mod_idx, (_, module)) in modules.iter().enumerate() {
let mut module_closures: Vec = Vec::new();
collect_closures_from_stmts(&module.init, &mut module_closures);
for global in &module.globals {
if let Some(init) = &global.init {
collect_closures_from_expr(init, &mut module_closures);
}
}
for func in &module.functions {
for param in &func.params {
if let Some(default) = ¶m.default {
collect_closures_from_expr(default, &mut module_closures);
}
}
collect_closures_from_stmts(&func.body, &mut module_closures);
}
for class in &module.classes {
let instance_start = module_closures.len();
if let Some(ctor) = &class.constructor {
for param in &ctor.params {
if let Some(default) = ¶m.default {
collect_closures_from_expr(default, &mut module_closures);
}
}
collect_closures_from_stmts(&ctor.body, &mut module_closures);
}
for method in &class.methods {
for param in &method.params {
if let Some(default) = ¶m.default {
collect_closures_from_expr(default, &mut module_closures);
}
}
collect_closures_from_stmts(&method.body, &mut module_closures);
}
let statics_start = module_closures.len();
for method in &class.static_methods {
for param in &method.params {
if let Some(default) = ¶m.default {
collect_closures_from_expr(default, &mut module_closures);
}
}
collect_closures_from_stmts(&method.body, &mut module_closures);
}
let statics_end = module_closures.len();
for (_, getter) in &class.getters {
for param in &getter.params {
if let Some(default) = ¶m.default {
collect_closures_from_expr(default, &mut module_closures);
}
}
collect_closures_from_stmts(&getter.body, &mut module_closures);
}
for (_, setter) in &class.setters {
for param in &setter.params {
if let Some(default) = ¶m.default {
collect_closures_from_expr(default, &mut module_closures);
}
}
collect_closures_from_stmts(&setter.body, &mut module_closures);
}
for field in &class.fields {
if let Some(init) = &field.init {
collect_closures_from_expr(init, &mut module_closures);
}
}
let instance_end = module_closures.len();
for field in &class.static_fields {
if let Some(init) = &field.init {
collect_closures_from_expr(init, &mut module_closures);
}
}
for closure in module_closures[instance_start..statics_start]
.iter()
.chain(&module_closures[statics_end..instance_end])
{
if closure.5 {
closure_class.insert((mod_idx, closure.0), class.name.clone());
}
}
}
// One function per FuncId: a closure the HIR reaches by two paths (a static
// field initializer is also in `init`) is emitted once.
let mut seen = std::collections::HashSet::new();
for (fid, params, body, caps, mut_caps, _) in module_closures {
if seen.insert(fid) {
closure_funcs.push((fid, params, body, caps, mut_caps, mod_idx));
}
}
}
// Register async functions as additional bridge imports (Phase 1: assign import indices).
// JS code generation is deferred to Phase 2 after per-module func_maps are built.
let mut async_import_idx = self.num_imports;
let mut per_module_async: Vec> = Vec::new();
for (_, module) in modules.iter() {
let mut module_async_entries = Vec::new();
for func in &module.functions {
if func.is_async {
let param_count = func.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64]; // returns promise handle
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
module_async_entries.push((func.id, async_import_idx));
self.func_name_map
.insert(func.name.clone(), async_import_idx);
// Record the param count so optional-arg padding at call sites
// (expr.rs Expr::Call → FuncRef/ExternFuncRef) works for async
// imports too. Without this, `await foo(a, b)` where foo is
// declared as `async function foo(a, b, c?)` emits only two
// i64 pushes before the call, while the import is declared as
// `(i64, i64, i64) -> i64`. Validator fails with
// "expected i64 but nothing on stack" (#1081 sibling instance).
self.func_param_counts.insert(async_import_idx, param_count);
self.async_func_imports.push((
func.name.clone(),
async_import_idx,
param_count,
));
async_import_idx += 1;
}
}
per_module_async.push(module_async_entries);
}
self.num_imports = async_import_idx;
// Register external FFI functions as WASM imports under the "ffi" namespace.
// These are `declare function` statements with no body (e.g., bloom_init_window).
// Deduplicate by name since the same extern can appear in multiple modules.
let mut ffi_import_idx = self.num_imports;
let mut seen_ffi: std::collections::BTreeSet = std::collections::BTreeSet::new();
for (_, module) in modules {
for (name, param_types, return_type) in &module.extern_funcs {
if seen_ffi.contains(name) {
continue;
}
seen_ffi.insert(name.clone());
let param_count = param_types.len();
let has_return = !matches!(return_type, perry_hir::types::Type::Void);
let params = vec![ValType::I64; param_count];
let results = if has_return {
vec![ValType::I64]
} else {
vec![]
};
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
self.func_name_map.insert(name.clone(), ffi_import_idx);
self.ffi_imports
.push((name.clone(), param_count, has_return));
ffi_import_idx += 1;
}
}
self.num_imports = ffi_import_idx;
// Now set user_func_idx AFTER all imports (including async and FFI) are registered
let mut user_func_idx = self.num_imports;
// __init_strings function
let init_strings_idx = user_func_idx;
let init_strings_type = t_void;
user_func_idx += 1;
// Register user functions from all modules (skip async ones).
// FuncId is only unique within a module, so we build per-module func_maps
// to avoid cross-module FuncId collisions (e.g., module A's FuncId(2) != module B's FuncId(2)).
for (mod_idx, (_, module)) in modules.iter().enumerate() {
let mut module_fm: BTreeMap = BTreeMap::new();
// Include async function mappings for this module
for &(fid, idx) in &per_module_async[mod_idx] {
module_fm.insert(fid, idx);
}
// Function names are NOT globally unique across modules (a
// serializer's local `function vec3(v): string` coexists with the
// math library's exported `vec3(x, y, z)`), but `func_name_map` —
// the ExternFuncRef cross-module resolution table — is keyed by
// bare name. Prefer EXPORTED functions (the only legitimate
// cross-module call targets); a module-local helper only claims a
// name nobody exported.
let exported_names: std::collections::HashSet<&str> = module
.exported_functions
.iter()
.map(|(n, _)| n.as_str())
.chain(module.exports.iter().filter_map(|e| match e {
perry_hir::ir::Export::Named { local, .. } => Some(local.as_str()),
_ => None,
}))
.collect();
for func in &module.functions {
if func.is_async {
continue; // already registered as bridge import
}
let param_count = func.params.len();
let params = vec![ValType::I64; param_count];
let results = if func.body.iter().any(has_return) || func.name == "main" {
vec![ValType::I64]
} else {
vec![]
};
let is_void = results.is_empty();
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
module_fm.insert(func.id, user_func_idx);
if is_void {
self.void_funcs.insert(user_func_idx);
}
self.func_param_counts.insert(user_func_idx, param_count);
// Build func_name_map for ExternFuncRef resolution. Exported
// functions win the name; module-local helpers only fill a
// vacant slot (see exported_names above).
if exported_names.contains(func.name.as_str()) {
self.func_name_map.insert(func.name.clone(), user_func_idx);
} else {
self.func_name_map
.entry(func.name.clone())
.or_insert(user_func_idx);
}
user_func_idx += 1;
}
self.module_func_maps.push(module_fm);
}
// Register class constructors, methods, and static methods
for (_, module) in modules {
for class in &module.classes {
self.user_classes.insert(class.name.clone());
// Record parent class relationship
if let Some(parent) = &class.extends_name {
self.class_parent_map
.insert(class.name.clone(), parent.clone());
}
// Constructor: params = this + declared params, returns f64 (this)
if let Some(ctor) = constructor_of(class, &classes) {
let param_count = 1 + ctor.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
self.class_ctor_map
.insert(class.name.clone(), user_func_idx);
self.func_param_counts.insert(user_func_idx, param_count);
user_func_idx += 1;
}
// Instance methods: params = this + declared params
for method in &class.methods {
let param_count = 1 + method.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
self.class_method_map
.entry(class.name.clone())
.or_default()
.insert(method.name.clone(), user_func_idx);
self.func_param_counts.insert(user_func_idx, param_count);
user_func_idx += 1;
}
// Static methods: no this param
for method in &class.static_methods {
let param_count = method.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
self.class_static_map
.entry(class.name.clone())
.or_default()
.insert(method.name.clone(), user_func_idx);
// Also register in func_name_map for cross-module resolution
self.func_name_map
.insert(format!("{}_{}", class.name, method.name), user_func_idx);
self.func_param_counts.insert(user_func_idx, param_count);
user_func_idx += 1;
}
// Getters: like methods with 0 params + this
for (name, getter) in &class.getters {
let params = vec![ValType::I64]; // just this
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
self.class_method_map
.entry(class.name.clone())
.or_default()
.insert(format!("__get_{}", name), user_func_idx);
self.func_param_counts.insert(user_func_idx, 1);
let _ = getter;
user_func_idx += 1;
}
// Setters: this + value
for (name, setter) in &class.setters {
let params = vec![ValType::I64; 2]; // this + value
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
let _ = type_idx;
self.class_method_map
.entry(class.name.clone())
.or_default()
.insert(format!("__set_{}", name), user_func_idx);
self.func_param_counts.insert(user_func_idx, 2);
let _ = setter;
user_func_idx += 1;
}
}
}
// Register closure functions into their per-module func_maps
for (func_id, params, body, captures, mutable_captures, mod_idx) in &closure_funcs {
if !self.module_func_maps[*mod_idx].contains_key(func_id) {
// Closure params: captures first (as f64), then declared params
let total_params = captures.len() + mutable_captures.len() + params.len();
let wasm_params = vec![ValType::I64; total_params];
let results = if body.iter().any(has_return) {
vec![ValType::I64]
} else {
vec![ValType::I64] // closures always return i64
};
let type_idx = self.get_type_idx(wasm_params, results);
let _ = type_idx;
self.module_func_maps[*mod_idx].insert(*func_id, user_func_idx);
user_func_idx += 1;
}
}
// Register globals from all modules. This precedes the async JS generation below,
// which reads `global_map` to tell a declared global from the unresolved-global
// sentinel.
for (_, module) in modules {
for global in &module.globals {
self.global_map.insert(global.id, self.num_globals);
self.num_globals += 1;
}
}
// Promote module-level Let bindings to WASM globals so cross-function
// references work and so different modules' identical LocalIds don't collide.
// This also precedes the async JS generation, whose bodies reach a module-level
// `let` through the exported global this map names.
for (mod_idx, (_, module)) in modules.iter().enumerate() {
collect_module_let_ids(
&module.init,
mod_idx,
&mut self.module_let_globals,
&mut self.num_globals,
);
}
// Module-level lets are wasm globals, already shared by every closure.
let mut boxed: Vec<(usize, LocalId)> = Vec::new();
for (_, _, body, _, mutable_captures, mod_idx) in &closure_funcs {
let ids = mutable_captures
.iter()
.chain(generator_record_captures(body));
boxed.extend(ids.map(|id| (*mod_idx, *id)));
}
for (mod_idx, (_, module)) in modules.iter().enumerate() {
let methods = module
.classes
.iter()
.flat_map(|class| class.methods.iter().chain(&class.static_methods));
for func in module.functions.iter().chain(methods) {
boxed.extend(
generator_record_captures(&func.body)
.iter()
.map(|id| (mod_idx, *id)),
);
}
}
for key in boxed {
if !self.module_let_globals.contains_key(&key) {
self.boxed_locals.insert(key);
}
}
// Async function JS generation (Phase 2): now that per-module func_maps are complete,
// generate the JS code for async functions with correct FuncRef resolution.
for (mod_idx, (_, module)) in modules.iter().enumerate() {
self.func_map = self.module_func_maps[mod_idx].clone();
self.current_mod_idx = mod_idx;
for func in &module.functions {
if func.is_async {
let js_code = self.emit_js_async_function(func);
self.async_js_code.push(js_code);
}
}
}
// _start function (entry point). #854: the trailing
// `user_func_idx += 1` was dead — nothing later in this function
// reads the counter.
let start_idx = user_func_idx;
let start_type = t_void;
// Issue #1071: build cross-module imported-variable → WASM global map.
// The HIR lowers `import { FOO } from './m'` value reads (where FOO is
// an exported `const`/`let`, not a function) to `Expr::ExternFuncRef {
// name: "FOO" }`. Pre-fix this hit `TAG_UNDEFINED` because `name`
// wasn't in `func_name_map` (it's a variable, not a function). Now we
// resolve `name` to the source module's `Stmt::Let` and reuse its
// wasm-global slot from `module_let_globals`. Same flow the LLVM target
// achieves via per-export `perry_fn___()` getter functions.
//
// Module-path lookup: each `Import` carries `resolved_path` (set by
// the driver) and `Module.name` is a relative-from-project-root path.
// We compare paths by file-stem match against `Module.name` (which is
// a leaf "name.ts" or "subdir/name.ts" string), falling back to a
// basename match. Re-exports (`Export::ReExport`, `ExportAll`, and the
// import-then-`export { x }` shape) are chased by
// `resolve_export_to_let` with a depth cap — a library facade like
// bloom's `index.ts` re-exporting `Key` from `core/keys.ts` is two to
// three hops deep, and stopping at the first module made every
// re-exported const OBJECT read undefined (scalars sometimes survived
// via other paths, which made the failure look random).
{
// module.name → source module index
let name_to_idx: std::collections::HashMap<&str, usize> = modules
.iter()
.enumerate()
.map(|(i, (_, m))| (m.name.as_str(), i))
.collect();
// For each source module, build a name → wasm global lookup over
// its top-level Lets so we can resolve `Export::Named { local }`.
let mut src_let_names: Vec> =
Vec::with_capacity(modules.len());
for (src_idx, (_, module)) in modules.iter().enumerate() {
let mut map: std::collections::HashMap = Default::default();
for stmt in &module.init {
if let perry_hir::Stmt::Let { id, name, .. } = stmt {
if let Some(&gidx) = self.module_let_globals.get(&(src_idx, *id)) {
map.insert(name.clone(), gidx);
}
}
}
src_let_names.push(map);
}
for (consumer_idx, (_, module)) in modules.iter().enumerate() {
for import in &module.imports {
if import.type_only {
continue;
}
// Resolve source module index. Prefer matching `resolved_path`
// against `(path, module)` pairs by stem; fall back to a
// suffix/basename match on `import.source`.
let src_idx_opt = resolve_source_module_idx(modules, import, &name_to_idx);
let Some(src_idx) = src_idx_opt else { continue };
for spec in &import.specifiers {
if let perry_hir::ir::ImportSpecifier::Named { imported, local } = spec {
// Resolve the public `imported` name to a let
// global, following re-export chains (see
// resolve_export_to_let).
let resolved = resolve_export_to_let(
modules,
&src_let_names,
&name_to_idx,
src_idx,
imported,
8,
);
if std::env::var("PERRY_WASM_DEBUG_IMPORTS").is_ok() {
eprintln!(
"[wasm-imports] {} imports {{ {} }} from {} -> module #{} ({}) => {:?}",
modules[consumer_idx].1.name,
imported,
import.source,
src_idx,
modules[src_idx].1.name,
resolved,
);
}
if let Some(gidx) = resolved {
self.imported_var_globals
.insert((consumer_idx, local.clone()), gidx);
}
// Function imports resolve per-consumer too — the
// whole-program func_name_map's bare-name keys
// collide across modules.
if let Some(fidx) = resolve_export_to_func(
modules,
&self.module_func_maps,
&name_to_idx,
src_idx,
imported,
8,
) {
self.imported_func_indices
.insert((consumer_idx, local.clone()), fidx);
}
}
// Namespace import (`import * as W from "./mod"`):
// register every exported module-level let under a
// DOTTED key ("W.MESH_COUNT"), so PropertyGet on the
// namespace ident resolves to the source module's
// promoted-let global — the same mechanism the Named
// arm above uses. Without this, every `W.member` read
// emitted a class_get_field on an undefined receiver
// and produced undefined (functions kept working via
// the whole-program name map, which made the failure
// maddeningly partial).
if let perry_hir::ir::ImportSpecifier::Namespace { local } = spec {
// Register `W.` for exactly the source
// module's PUBLIC surface — its named/re-exported/
// function/object exports, plus everything reached
// through `export * from "..."` (recursively). This
// replaced a blanket "register every module-level
// let" loop, which both exposed PRIVATE locals as
// `W.private` (not valid JS namespace members) and
// missed `export *` re-exports entirely.
let mut public: std::collections::BTreeSet =
std::collections::BTreeSet::new();
collect_exported_names(modules, src_idx, 8, &mut public);
for name in &public {
if let Some(gidx) = resolve_export_to_let(
modules,
&src_let_names,
&name_to_idx,
src_idx,
name,
8,
) {
self.imported_var_globals.insert(
(consumer_idx, format!("{}.{}", local, name)),
gidx,
);
}
if let Some(fidx) = resolve_export_to_func(
modules,
&self.module_func_maps,
&name_to_idx,
src_idx,
name,
8,
) {
self.imported_ns_funcs
.entry((consumer_idx, format!("{}.{}", local, name)))
.or_insert(fidx);
}
}
}
}
}
}
}
// Add a NaN-safe temp global for mem_store_slot (Firefox canonicalizes locals)
self.nan_temp_global = self.num_globals;
self.num_globals += 1;
// Build the WASM module
let mut wasm_module = Module::new();
// --- Type section ---
let mut type_section = TypeSection::new();
for (params, results) in &self.types {
type_section
.ty()
.function(params.iter().copied(), results.iter().copied());
}
wasm_module.section(&type_section);
// --- Import section ---
let mut import_section = ImportSection::new();
for (name, type_idx) in &import_entries {
import_section.import("rt", name, EntityType::Function(*type_idx));
}
// Add async function imports
let async_import_entries: Vec<(String, u32)> = self
.async_func_imports
.iter()
.map(|(name, _idx, param_count)| {
let import_name = format!("__async_{}", name);
let params = vec![ValType::I64; *param_count];
let results = vec![ValType::I64];
let key = (params, results);
let type_idx = self.type_map.get(&key).copied().unwrap_or(0);
(import_name, type_idx)
})
.collect();
for (name, type_idx) in &async_import_entries {
import_section.import("rt", name, EntityType::Function(*type_idx));
}
// Add FFI function imports under "ffi" namespace
for (name, param_count, has_return) in &self.ffi_imports {
let params = vec![ValType::I64; *param_count];
let results = if *has_return {
vec![ValType::I64]
} else {
vec![]
};
let key = (params, results);
let type_idx = self.type_map.get(&key).copied().unwrap_or(0);
import_section.import("ffi", name, EntityType::Function(type_idx));
}
wasm_module.section(&import_section);
// --- Function section (declares type indices for each defined function) ---
let mut func_section = FunctionSection::new();
// __init_strings
func_section.function(init_strings_type);
// User functions (skip async — they are imports)
for (_, module) in modules {
for func in &module.functions {
if func.is_async {
continue;
}
let param_count = func.params.len();
let params = vec![ValType::I64; param_count];
let results = if func.body.iter().any(has_return) || func.name == "main" {
vec![ValType::I64]
} else {
vec![]
};
let type_idx = self.get_type_idx(params, results);
func_section.function(type_idx);
}
}
// Class constructors, methods, static methods, getters, setters
for (_, module) in modules {
for class in &module.classes {
if let Some(ctor) = constructor_of(class, &classes) {
let param_count = 1 + ctor.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
func_section.function(type_idx);
}
for method in &class.methods {
let param_count = 1 + method.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
func_section.function(type_idx);
}
for method in &class.static_methods {
let param_count = method.params.len();
let params = vec![ValType::I64; param_count];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
func_section.function(type_idx);
}
for (_name, _getter) in &class.getters {
let params = vec![ValType::I64];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
func_section.function(type_idx);
}
for (_name, _setter) in &class.setters {
let params = vec![ValType::I64; 2];
let results = vec![ValType::I64];
let type_idx = self.get_type_idx(params, results);
func_section.function(type_idx);
}
}
}
// Closure functions
for (func_id, _params, _body, captures, mutable_captures, mod_idx) in &closure_funcs {
if self.module_func_maps[*mod_idx].contains_key(func_id) {
let total_params = captures.len() + mutable_captures.len() + _params.len();
let wasm_params = vec![ValType::I64; total_params];
let results = vec![ValType::I64]; // closures always return f64
let type_idx = self.get_type_idx(wasm_params, results);
func_section.function(type_idx);
}
}
// _start
func_section.function(start_type);
wasm_module.section(&func_section);
// --- Table section (for indirect calls / closures) ---
// Must come after Function section but before Memory section (WASM spec ordering)
let all_func_indices: Vec = {
let mut indices = vec![init_strings_idx]; // placeholder at index 0
for (mod_idx, (_, module)) in modules.iter().enumerate() {
for func in &module.functions {
if let Some(&idx) = self.module_func_maps[mod_idx].get(&func.id) {
indices.push(idx);
}
}
}
// Add class constructor/method/static indices
for idx in self.class_ctor_map.values() {
if !indices.contains(idx) {
indices.push(*idx);
}
}
for methods in self.class_method_map.values() {
for idx in methods.values() {
if !indices.contains(idx) {
indices.push(*idx);
}
}
}
for statics in self.class_static_map.values() {
for idx in statics.values() {
if !indices.contains(idx) {
indices.push(*idx);
}
}
}
for (func_id, _, _, _, _, mod_idx) in &closure_funcs {
if let Some(&idx) = self.module_func_maps[*mod_idx].get(func_id) {
if !indices.contains(&idx) {
indices.push(idx);
}
}
}
indices.push(start_idx);
indices
};
// Build reverse map: wasm func index → table position
for (table_idx, &func_idx) in all_func_indices.iter().enumerate() {
self.func_to_table_idx.insert(func_idx, table_idx as u32);
}
let table_size = all_func_indices.len() as u32;
{
let mut table_section = TableSection::new();
table_section.table(TableType {
element_type: RefType::FUNCREF,
minimum: table_size as u64,
maximum: Some(table_size as u64),
table64: false,
shared: false,
});
wasm_module.section(&table_section);
}
// --- Memory section ---
let mut mem_section = MemorySection::new();
let pages = self.string_data.len().div_ceil(65536).max(2) as u64; // min 2 pages for 0xFF00 mem_call region
mem_section.memory(MemoryType {
minimum: pages,
maximum: None,
memory64: false,
shared: false,
page_size_log2: None,
});
wasm_module.section(&mem_section);
// --- Global section ---
if self.num_globals > 0 {
let mut global_section = GlobalSection::new();
for g in 0..self.num_globals {
if g == self.nan_temp_global {
// Stack pointer for arg buffer (i32, initialized to 0x10000)
global_section.global(
GlobalType {
val_type: ValType::I32,
mutable: true,
shared: false,
},
&wasm_encoder::ConstExpr::i32_const(0x10000),
);
} else {
// Regular i64 global for module-level variables (NaN-boxed)
global_section.global(
GlobalType {
val_type: ValType::I64,
mutable: true,
shared: false,
},
&wasm_encoder::ConstExpr::i64_const(TAG_UNDEFINED as i64),
);
}
}
wasm_module.section(&global_section);
}
// --- Export section ---
let mut export_section = ExportSection::new();
export_section.export("_start", ExportKind::Func, start_idx);
export_section.export("memory", ExportKind::Memory, 0);
export_section.export("__indirect_function_table", ExportKind::Table, 0);
// Export all user functions so async JS code can call them by index.
for idx in self.num_imports..start_idx {
export_section.export(&format!("__wasm_func_{}", idx), ExportKind::Func, idx);
}
// Issue #1071: export the globals that back cross-module imported
// variables so the async/JS-context emission path (which can't issue
// a `global.get` instruction) can read them via
// `wasmInstance.exports.__wasm_global_.value`. We export ALL
// module-let globals since they're already named by index and the
// export cost is negligible; future asynchrony work that needs the
// same boundary read won't have to wire a separate index.
{
let mut exported_globals: std::collections::BTreeSet =
std::collections::BTreeSet::new();
for &gidx in self.module_let_globals.values() {
exported_globals.insert(gidx);
}
for &gidx in self.global_map.values() {
exported_globals.insert(gidx);
}
for gidx in exported_globals {
export_section.export(&format!("__wasm_global_{}", gidx), ExportKind::Global, gidx);
}
}
wasm_module.section(&export_section);
// --- Element section (populate the indirect call table) ---
{
let mut elem_section = ElementSection::new();
elem_section.active(
Some(0), // table index
&wasm_encoder::ConstExpr::i32_const(0), // offset
Elements::Functions(std::borrow::Cow::Borrowed(&all_func_indices)),
);
wasm_module.section(&elem_section);
}
// --- DataCount section (required before Code when Data section exists) ---
if !self.string_data.is_empty() {
wasm_module.section(&wasm_encoder::DataCountSection { count: 1 });
}
// --- Code section ---
let mut code_section = CodeSection::new();
// __init_strings: register all string literals with the JS runtime
{
let mut func = Function::new(vec![]);
for (_content, offset, len) in &self.string_table {
func.instruction(&Instruction::I32Const(*offset as i32));
func.instruction(&Instruction::I32Const(*len as i32));
func.instruction(&Instruction::Call(rt.string_new));
}
func.instruction(&Instruction::End);
code_section.function(&func);
}
// User functions (skip async — they are JS bridge imports).
// Swap in the per-module func_map so FuncRef(id) resolves correctly within each module.
for (mod_idx, (_, module)) in modules.iter().enumerate() {
self.func_map = self.module_func_maps[mod_idx].clone();
self.current_mod_idx = mod_idx;
for hir_func in &module.functions {
if hir_func.is_async {
continue;
}
let func = self.compile_function(hir_func);
code_section.function(&func);
}
}
// Class constructors, methods, static methods, getters, setters
for (mod_idx, (_, module)) in modules.iter().enumerate() {
self.func_map = self.module_func_maps[mod_idx].clone();
self.current_mod_idx = mod_idx;
for class in &module.classes {
if let Some(ctor) = constructor_of(class, &classes) {
let func = self.compile_class_constructor(class, &ctor);
code_section.function(&func);
}
for method in &class.methods {
let func = self.compile_class_method(&class.name, method);
code_section.function(&func);
}
for method in &class.static_methods {
// Static methods are declared as `(params) -> i64` in
// func_section (mod.rs:1701) unconditionally, so the
// body emitter must also assume i64-returning regardless
// of whether the body has an explicit `Stmt::Return`.
// Otherwise a static method that only throws (or only
// falls through) produces a WASM body whose `return`
// instructions leave an empty operand stack — V8 rejects
// with "expected i64 but nothing on stack".
let func = self.compile_function_with_signature(method, true);
code_section.function(&func);
}
for (_name, getter) in &class.getters {
let func = self.compile_class_method(&class.name, getter);
code_section.function(&func);
}
for (_name, setter) in &class.setters {
let func = self.compile_class_method(&class.name, setter);
code_section.function(&func);
}
}
}
// Closure functions — swap in the parent module's func_map for each closure
for (func_id, params, body, captures, mutable_captures, mod_idx) in &closure_funcs {
if self.module_func_maps[*mod_idx].contains_key(func_id) {
self.func_map = self.module_func_maps[*mod_idx].clone();
self.current_mod_idx = *mod_idx;
let home_class = closure_class.get(&(*mod_idx, *func_id)).map(String::as_str);
let func =
self.compile_closure(params, body, captures, mutable_captures, home_class);
code_section.function(&func);
}
}
// _start: call __init_strings, then execute module init code
{
// Collect locals PER-MODULE so LocalIds don't collide across modules.
// Each module declares Lets starting from id 0, so without per-module maps
// module B's `let id=1` would alias module A's `let id=1`.
let mut per_module_init_locals: Vec> =
Vec::with_capacity(modules.len());
let mut total_count = 0u32;
for (_, module) in modules {
let mut mod_map = BTreeMap::new();
collect_locals(&module.init, &mut mod_map, &mut total_count, 0);
for global in &module.globals {
if let Some(init) = &global.init {
collect_expr_locals(init, &mut mod_map, &mut total_count, 0);
}
}
for class in &module.classes {
for field in &class.static_fields {
if let Some(init) = &field.init {
collect_expr_locals(init, &mut mod_map, &mut total_count, 0);
}
}
}
per_module_init_locals.push(mod_map);
}
// Global and static-field initializers use the module activation locals.
let num_locals = total_count;
let start_temp_local = num_locals;
let start_temp_i32 = num_locals + 3;
let locals = vec![(num_locals + 3, ValType::I64), (1, ValType::I32)];
let mut func = Function::new(locals);
// Call __init_strings first
func.instruction(&Instruction::Call(init_strings_idx));
// Initialize globals — swap in per-module func_map for correct FuncRef resolution
for (mod_idx, (_, module)) in modules.iter().enumerate() {
self.func_map = self.module_func_maps[mod_idx].clone();
// Per-consumer import resolution (imported_var_globals /
// imported_func_indices / imported_ns_funcs) is keyed by
// current_mod_idx; a module-scope initializer that calls an
// imported symbol (e.g. `const P = vec3(...)`) resolves
// against a stale consumer without this and could bind
// another module's like-named export.
self.current_mod_idx = mod_idx;
for global in &module.globals {
if let Some(init) = &global.init {
let mut ctx = FuncEmitCtx::new(
self,
&per_module_init_locals[mod_idx],
start_temp_local,
start_temp_i32,
);
ctx.returns_value = false;
ctx.emit_expr(&mut func, init);
let gidx = self.global_map[&global.id];
func.instruction(&Instruction::GlobalSet(gidx));
} else if global.name == "__platform__" {
// Web platform ID = 5
func.instruction(&f64_const(5.0));
func.instruction(&Instruction::I64ReinterpretF64);
let gidx = self.global_map[&global.id];
func.instruction(&Instruction::GlobalSet(gidx));
}
}
}
// Register class methods with the bridge and set up inheritance
for (mod_idx, (_, module)) in modules.iter().enumerate() {
self.func_map = self.module_func_maps[mod_idx].clone();
self.current_mod_idx = mod_idx; // see the globals loop above
for class in &module.classes {
let class_name_id = self
.string_map
.get(class.name.as_str())
.copied()
.unwrap_or(0);
let class_bits = (STRING_TAG << 48) | (class_name_id as u64);
// Register instance methods in classMethodTable (including getters/setters)
if let Some(methods) = self.class_method_map.get(&class.name) {
for (method_name, &func_idx) in methods {
let real_name = method_name.as_str();
let method_name_id =
self.string_map.get(real_name).copied().unwrap_or(0);
let method_bits = (STRING_TAG << 48) | (method_name_id as u64);
let table_idx = self
.func_to_table_idx
.get(&func_idx)
.copied()
.unwrap_or(func_idx);
// Store args to memory for mem_call (Firefox NaN-safe: use I64Store)
func.instruction(&Instruction::I32Const(0xFF00));
func.instruction(&Instruction::I64Const(class_bits as i64));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
func.instruction(&Instruction::I32Const(0xFF08));
func.instruction(&Instruction::I64Const(method_bits as i64));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
func.instruction(&Instruction::I32Const(0xFF10));
func.instruction(&Instruction::I64Const(
(table_idx as f64).to_bits() as i64
));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
let csm_id = self
.string_map
.get("class_set_method")
.copied()
.unwrap_or(0);
func.instruction(&f64_const(csm_id as f64));
func.instruction(&f64_const(3.0));
func.instruction(&Instruction::I32Const(0xFF00));
func.instruction(&Instruction::Call(rt.mem_call));
func.instruction(&Instruction::Drop);
}
}
// Set up inheritance
if let Some(parent_name) = &class.extends_name {
let parent_name_id = self
.string_map
.get(parent_name.as_str())
.copied()
.unwrap_or(0);
let parent_bits = (STRING_TAG << 48) | (parent_name_id as u64);
func.instruction(&Instruction::I32Const(0xFF00));
func.instruction(&Instruction::I64Const(class_bits as i64));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
func.instruction(&Instruction::I32Const(0xFF08));
func.instruction(&Instruction::I64Const(parent_bits as i64));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
let csp_id = self
.string_map
.get("class_set_parent")
.copied()
.unwrap_or(0);
func.instruction(&f64_const(csp_id as f64));
func.instruction(&f64_const(2.0));
func.instruction(&Instruction::I32Const(0xFF00));
func.instruction(&Instruction::Call(rt.mem_call));
func.instruction(&Instruction::Drop);
}
// Register static fields
for field in &class.static_fields {
if let Some(init) = &field.init {
let field_name_id = self
.string_map
.get(field.name.as_str())
.copied()
.unwrap_or(0);
let field_bits = (STRING_TAG << 48) | (field_name_id as u64);
// Store class name
func.instruction(&Instruction::I32Const(0xFF00));
func.instruction(&Instruction::I64Const(class_bits as i64));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
// Store field name
func.instruction(&Instruction::I32Const(0xFF08));
func.instruction(&Instruction::I64Const(field_bits as i64));
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
// Store value
let mut ctx = FuncEmitCtx::new(
self,
&per_module_init_locals[mod_idx],
start_temp_local,
start_temp_i32,
);
ctx.returns_value = false;
ctx.emit_expr(&mut func, init);
// Use temp local to store the value
func.instruction(&Instruction::LocalSet(start_temp_local));
func.instruction(&Instruction::I32Const(0xFF10));
func.instruction(&Instruction::LocalGet(start_temp_local));
// Value is already i64, no conversion needed
func.instruction(&Instruction::I64Store(wasm_encoder::MemArg {
offset: 0,
align: 3,
memory_index: 0,
}));
let css_id = self
.string_map
.get("class_set_static")
.copied()
.unwrap_or(0);
func.instruction(&f64_const(css_id as f64));
func.instruction(&f64_const(3.0));
func.instruction(&Instruction::I32Const(0xFF00));
func.instruction(&Instruction::Call(rt.mem_call));
func.instruction(&Instruction::Drop);
}
}
}
}
// Execute init statements from all modules — swap in per-module func_map
// and per-module local map so LocalGets resolve to the correct WASM local
// (or fall back to module_let_globals via current_mod_idx).
for (mod_idx, (_, module)) in modules.iter().enumerate() {
self.func_map = self.module_func_maps[mod_idx].clone();
self.current_mod_idx = mod_idx;
let mod_locals = &per_module_init_locals[mod_idx];
let mut ctx = FuncEmitCtx::new(self, mod_locals, start_temp_local, start_temp_i32);
ctx.returns_value = false;
for stmt in &module.init {
ctx.emit_stmt(&mut func, stmt, false);
}
}
func.instruction(&Instruction::End);
code_section.function(&func);
}
wasm_module.section(&code_section);
// --- Data section (string literal bytes, must come after Code) ---
if !self.string_data.is_empty() {
let mut data_section = DataSection::new();
data_section.active(
0,
&wasm_encoder::ConstExpr::i32_const(0),
self.string_data.iter().copied(),
);
wasm_module.section(&data_section);
}
let wasm_bytes = wasm_module.finish();
let async_js = self.async_js_code.join("\n");
let ffi_import_names = self
.ffi_imports
.iter()
.map(|(name, _, _)| name.clone())
.collect();
WasmCompileOutput {
wasm_bytes,
async_js,
ffi_imports: ffi_import_names,
}
}
}
#[cfg(test)]
#[path = "tests.rs"]
mod tests;