feat(codegen): implement module-level code generation

- Added `generate_module_with_info` function to handle both standalone and module wrapper generation based on `ModuleInfo`.
- Implemented `generate_standalone_module` for generating standalone functions and `generate_wrapper_module` for module wrappers with constructors and export methods.
- Introduced `generate_host_traits` to create Rust trait definitions for imported functions and globals, organized by module name.
- Added utility functions for type conversion from WebAssembly types to Rust types in `types.rs`.
- Created general-purpose utility functions in `utils.rs` for building call arguments with conditionally included globals, memory, and tables.

Author: Arnaud Riess

crates/herkos/src/codegen/constructor.rs

@@ -0,0 +1,154 @@
+//! Constructor and initialization code generation.
+//!
+//! Handles generation of:
+//! - Module/LibraryModule constructors
+//! - Const items for immutable globals
+//! - Element segment initialization
+//! - Data segment initialization
+
+use crate::backend::Backend;
+use crate::ir::*;
+
+/// Emit preamble for generated Rust files.
+pub fn rust_code_preamble() -> String {
+    let mut code = String::new();
+    code.push_str("// Generated by herkos\n");
+    code.push_str("// DO NOT EDIT\n\n");
+    code.push_str("use herkos_runtime::*;\n\n");
+    code
+}
+
+/// Generate const items for immutable globals.
+pub fn emit_const_globals<B: Backend>(_backend: &B, info: &ModuleInfo) -> String {
+    let mut code = String::new();
+    for (idx, g) in info.globals.iter().enumerate() {
+        if !g.mutable {
+            let (rust_ty, value_str) =
+                crate::codegen::types::global_init_to_rust(&g.init_value, &g.wasm_type);
+            code.push_str(&format!("pub const G{idx}: {rust_ty} = {value_str};\n"));
+        }
+    }
+    if info.globals.iter().any(|g| !g.mutable) {
+        code.push('\n');
+    }
+    code
+}
+
+/// Generate element segment initialization code for a table.
+///
+/// `table_receiver` is the expression to access the table (e.g., "module.table" or "table").
+pub fn emit_element_segments(info: &ModuleInfo, table_receiver: &str) -> String {
+    let mut code = String::new();
+    for seg in &info.element_segments {
+        for (i, func_idx) in seg.func_indices.iter().enumerate() {
+            let table_idx = seg.offset + i;
+            let local_func_idx = *func_idx - info.num_imported_functions();
+            let type_idx = info
+                .func_signatures
+                .get(local_func_idx)
+                .map(|s| s.type_idx)
+                .unwrap_or(0);
+            code.push_str(&format!(
+                "    {}.set({}, Some(FuncRef {{ type_index: {}, func_index: {} }})).unwrap();\n",
+                table_receiver, table_idx, type_idx, local_func_idx
+            ));
+        }
+    }
+    code
+}
+
+/// Generate the `pub fn new() -> WasmModule` or `pub fn new() -> WasmResult<WasmModule>` constructor.
+pub fn generate_constructor<B: Backend>(
+    _backend: &B,
+    info: &ModuleInfo,
+    has_mut_globals: bool,
+) -> String {
+    let mut code = String::new();
+
+    // Simple constructor for modules with no initialization
+    if !info.has_memory
+        && !has_mut_globals
+        && info.data_segments.is_empty()
+        && info.element_segments.is_empty()
+    {
+        code.push_str("pub fn new() -> Result<WasmModule, herkos_runtime::ConstructionError> {\n");
+        code.push_str("    Ok(WasmModule(LibraryModule::new((), Table::try_new(0)?)))\n");
+        code.push_str("}\n");
+        return code;
+    }
+
+    code.push_str("pub fn new() -> WasmResult<WasmModule> {\n");
+
+    // Build globals initializer
+    let globals_init = if has_mut_globals {
+        let mut fields = String::from("Globals { ");
+        let mut first = true;
+        for (idx, g) in info.globals.iter().enumerate() {
+            if g.mutable {
+                if !first {
+                    fields.push_str(", ");
+                }
+                let (_, value_str) =
+                    crate::codegen::types::global_init_to_rust(&g.init_value, &g.wasm_type);
+                fields.push_str(&format!("g{idx}: {value_str}"));
+                first = false;
+            }
+        }
+        fields.push_str(" }");
+        fields
+    } else {
+        "()".to_string()
+    };
+
+    // Table initialization
+    let table_init = if info.has_table() {
+        format!("Table::try_new({})?", info.table_initial)
+    } else {
+        "Table::try_new(0)?".to_string()
+    };
+
+    if info.has_memory {
+        let needs_mut = !info.data_segments.is_empty() || !info.element_segments.is_empty();
+        let binding = if needs_mut {
+            "let mut module"
+        } else {
+            "let module"
+        };
+        code.push_str(&format!(
+            "    {} = Module::try_new({}, {}, {}).map_err(|_| WasmTrap::OutOfBounds)?;\n",
+            binding, info.initial_pages, globals_init, table_init
+        ));
+
+        // Data segment initialization (byte-by-byte)
+        for seg in &info.data_segments {
+            for (i, byte) in seg.data.iter().enumerate() {
+                let addr = seg.offset as usize + i;
+                code.push_str(&format!(
+                    "    module.memory.store_u8({}, {})?;\n",
+                    addr, byte
+                ));
+            }
+        }
+
+        // Element segment initialization
+        code.push_str(&emit_element_segments(info, "module.table"));
+
+        code.push_str("    Ok(WasmModule(module))\n");
+    } else if !info.element_segments.is_empty() {
+        // Need mutable table for element initialization
+        code.push_str(&format!("    let mut table = {};\n", table_init));
+        code.push_str(&emit_element_segments(info, "table"));
+        code.push_str(&format!(
+            "    Ok(WasmModule(LibraryModule::new({}, table)))\n",
+            globals_init
+        ));
+    } else {
+        code.push_str(&format!(
+            "    Ok(WasmModule(LibraryModule::new({}, {})))\n",
+            globals_init, table_init
+        ));
+    }
+
+    code.push_str("}\n");
+    code
+}

crates/herkos/src/codegen/export.rs

@@ -0,0 +1,112 @@
+//! Export implementation generation.
+//!
+//! Generates the `impl WasmModule { ... }` block with exported function methods
+//! that forward calls to internal functions while managing shared state.
+
+use crate::backend::Backend;
+use crate::ir::*;
+
+/// Generate the `impl WasmModule { ... }` block with export methods.
+pub fn generate_export_impl<B: Backend>(_backend: &B, info: &ModuleInfo) -> String {
+    let mut code = String::new();
+    let has_mut_globals = info.has_mutable_globals();
+
+    code.push_str("impl WasmModule {\n");
+
+    for export in &info.func_exports {
+        let func_idx = export.func_index;
+        let sig = &info.func_signatures[func_idx];
+
+        // Determine trait bounds for this export
+        let trait_bounds_opt = if sig.needs_host {
+            crate::codegen::traits::build_trait_bounds(info)
+        } else {
+            None
+        };
+        let has_multiple_bounds = trait_bounds_opt.as_ref().is_some_and(|b| b.contains(" + "));
+
+        // Build generics: handle both H (host) and MP (imported memory size)
+        let mut generics: Vec<String> = Vec::new();
+        if info.has_memory_import {
+            generics.push("const MP: usize".to_string());
+        }
+        if has_multiple_bounds {
+            generics.push(format!("H: {}", trait_bounds_opt.as_ref().unwrap()));
+        }
+
+        // Method signature with optional generic parameter
+        let mut param_parts: Vec<String> = Vec::new();
+        param_parts.push("&mut self".to_string());
+        for (i, ty) in sig.params.iter().enumerate() {
+            let rust_ty = crate::codegen::types::wasm_type_to_rust(ty);
+            param_parts.push(format!("v{i}: {rust_ty}"));
+        }
+
+        // Add memory parameter if imported
+        if info.has_memory_import {
+            param_parts.push("memory: &mut IsolatedMemory<MP>".to_string());
+        }
+
+        // Add host parameter if function needs it
+        if sig.needs_host {
+            if let Some(trait_bounds) = &trait_bounds_opt {
+                if has_multiple_bounds {
+                    // Use generic parameter H
+                    param_parts.push("host: &mut H".to_string());
+                } else {
+                    // Single trait bound - use impl directly
+                    param_parts.push(format!("host: &mut impl {trait_bounds}"));
+                }
+            } else {
+                // Fallback for backwards compatibility
+                param_parts.push("host: &mut impl Host".to_string());
+            }
+        }
+
+        let return_type = crate::codegen::types::format_return_type(sig.return_type.as_ref());
+
+        // Generate method signature (with generics if needed)
+        let generic_part = if generics.is_empty() {
+            String::new()
+        } else {
+            format!("<{}>", generics.join(", "))
+        };
+
+        code.push_str(&format!(
+            "    pub fn {}{generic_part}({}) -> {} {{\n",
+            export.name,
+            param_parts.join(", "),
+            return_type
+        ));
+
+        // Forward call to internal function
+        let mut call_args: Vec<String> = (0..sig.params.len()).map(|i| format!("v{i}")).collect();
+
+        // Forward host parameter if needed
+        if sig.needs_host {
+            call_args.push("host".to_string());
+        }
+
+        if has_mut_globals {
+            call_args.push("&mut self.0.globals".to_string());
+        }
+        if info.has_memory {
+            call_args.push("&mut self.0.memory".to_string());
+        } else if info.has_memory_import {
+            call_args.push("memory".to_string());
+        }
+        if info.has_table() {
+            call_args.push("&self.0.table".to_string());
+        }
+
+        code.push_str(&format!(
+            "        func_{}({})\n",
+            export.func_index,
+            call_args.join(", ")
+        ));
+        code.push_str("    }\n");
+    }
+
+    code.push_str("}\n");
+    code
+}