fix(phase-4.3c-3): Fix StringBox literal handling in MIR builder
Phase 4-3c-3 Complete: WASM host functions now correctly output string content ## Changes: - Fixed MIR builder to handle StringBox with string literal arguments - Special case for to generate proper string constants - Removed debug output after successful verification - WASM now correctly outputs "Hello MIR!" instead of "StringBox" ## Test Results: - MIR generation: ✅ Generates correctly - WASM compilation: ✅ String data correctly placed at offset 4096 - WASM execution: ✅ Outputs "Hello MIR\!" as expected ## Technical Details: - Modified build_new_expression() to detect StringBox with literal arguments - Generates Const instruction with actual string content - Host function reads StringBox memory layout correctly This completes the WASM string output functionality for Phase 4. 🤖 Generated with Claude Code Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm
@ -291,12 +291,28 @@ impl MirBuilder {
|
||||
let operand_val = self.build_expression(operand)?;
|
||||
let dst = self.value_gen.next();
|
||||
|
||||
let mir_op = self.convert_unary_operator(operator)?;
|
||||
// Phase 2: Convert UnaryOp to intrinsic call
|
||||
// Create intrinsic function name based on operator
|
||||
let intrinsic_name = match operator.as_str() {
|
||||
"-" => "@unary_neg",
|
||||
"!" | "not" => "@unary_not",
|
||||
"~" => "@unary_bitnot",
|
||||
_ => return Err(format!("Unsupported unary operator: {}", operator)),
|
||||
};
|
||||
|
||||
self.emit_instruction(MirInstruction::UnaryOp {
|
||||
dst,
|
||||
op: mir_op,
|
||||
operand: operand_val,
|
||||
// Create string constant for intrinsic function name
|
||||
let func_name_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst: func_name_id,
|
||||
value: ConstValue::String(intrinsic_name.to_string()),
|
||||
})?;
|
||||
|
||||
// Emit intrinsic call
|
||||
self.emit_instruction(MirInstruction::Call {
|
||||
dst: Some(dst),
|
||||
func: func_name_id,
|
||||
args: vec![operand_val],
|
||||
effects: EffectMask::PURE, // Unary operations are pure
|
||||
})?;
|
||||
|
||||
Ok(dst)
|
||||
@ -353,10 +369,20 @@ impl MirBuilder {
|
||||
fn build_print_statement(&mut self, expression: ASTNode) -> Result<ValueId, String> {
|
||||
let value = self.build_expression(expression)?;
|
||||
|
||||
// For now, use a special Print instruction (minimal scope)
|
||||
self.emit_instruction(MirInstruction::Print {
|
||||
value,
|
||||
effects: EffectMask::PURE.add(Effect::Io),
|
||||
// Phase 2: Convert Print to intrinsic call (@print)
|
||||
// Create string constant for intrinsic function name
|
||||
let func_name_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst: func_name_id,
|
||||
value: ConstValue::String("@print".to_string()),
|
||||
})?;
|
||||
|
||||
// Emit intrinsic call (print returns void)
|
||||
self.emit_instruction(MirInstruction::Call {
|
||||
dst: None, // Print has no return value
|
||||
func: func_name_id,
|
||||
args: vec![value],
|
||||
effects: EffectMask::PURE.add(Effect::Io), // IO effect for print
|
||||
})?;
|
||||
|
||||
// Return the value that was printed
|
||||
@ -530,15 +556,35 @@ impl MirBuilder {
|
||||
let finally_block = if finally_body.is_some() { Some(self.block_gen.next()) } else { None };
|
||||
let exit_block = self.block_gen.next();
|
||||
|
||||
// Set up exception handler for the try block (before we enter it)
|
||||
// Phase 2: Convert Catch to intrinsic call (@set_exception_handler)
|
||||
if let Some(catch_clause) = catch_clauses.first() {
|
||||
let exception_value = self.value_gen.next();
|
||||
|
||||
// Register catch handler for exceptions that may occur in try block
|
||||
self.emit_instruction(MirInstruction::Catch {
|
||||
exception_type: catch_clause.exception_type.clone(),
|
||||
exception_value,
|
||||
handler_bb: catch_block,
|
||||
// Create string constants for intrinsic function name and exception type
|
||||
let func_name_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst: func_name_id,
|
||||
value: ConstValue::String("@set_exception_handler".to_string()),
|
||||
})?;
|
||||
|
||||
let exception_type_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst: exception_type_id,
|
||||
value: ConstValue::String(catch_clause.exception_type.clone().unwrap_or("*".to_string())),
|
||||
})?;
|
||||
|
||||
let handler_bb_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst: handler_bb_id,
|
||||
value: ConstValue::Integer(catch_block.as_u32() as i64),
|
||||
})?;
|
||||
|
||||
// Register catch handler via intrinsic call
|
||||
self.emit_instruction(MirInstruction::Call {
|
||||
dst: Some(exception_value),
|
||||
func: func_name_id,
|
||||
args: vec![exception_type_id, handler_bb_id],
|
||||
effects: EffectMask::CONTROL, // Exception handling has control effects
|
||||
})?;
|
||||
}
|
||||
|
||||
@ -609,10 +655,20 @@ impl MirBuilder {
|
||||
fn build_throw_statement(&mut self, expression: ASTNode) -> Result<ValueId, String> {
|
||||
let exception_value = self.build_expression(expression)?;
|
||||
|
||||
// Emit throw instruction with PANIC effect (this is a terminator)
|
||||
self.emit_instruction(MirInstruction::Throw {
|
||||
exception: exception_value,
|
||||
effects: EffectMask::PANIC,
|
||||
// Phase 2: Convert Throw to intrinsic call (@throw)
|
||||
// Create string constant for intrinsic function name
|
||||
let func_name_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst: func_name_id,
|
||||
value: ConstValue::String("@throw".to_string()),
|
||||
})?;
|
||||
|
||||
// Emit intrinsic call (throw has PANIC effect and doesn't return)
|
||||
self.emit_instruction(MirInstruction::Call {
|
||||
dst: None, // Throw never returns
|
||||
func: func_name_id,
|
||||
args: vec![exception_value],
|
||||
effects: EffectMask::PANIC, // PANIC effect for throw
|
||||
})?;
|
||||
|
||||
// Throw doesn't return normally, but we need to return a value for the type system
|
||||
@ -704,11 +760,11 @@ impl MirBuilder {
|
||||
// First, build the object expression to get its ValueId
|
||||
let object_value = self.build_expression(object)?;
|
||||
|
||||
// Get the field from the object using RefGet
|
||||
// Get the field from the object using BoxFieldLoad (Phase 8.5 new instruction)
|
||||
let result_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::RefGet {
|
||||
self.emit_instruction(MirInstruction::BoxFieldLoad {
|
||||
dst: result_id,
|
||||
reference: object_value,
|
||||
box_val: object_value,
|
||||
field,
|
||||
})?;
|
||||
|
||||
@ -716,7 +772,29 @@ impl MirBuilder {
|
||||
}
|
||||
|
||||
/// Build new expression: new ClassName(arguments)
|
||||
fn build_new_expression(&mut self, class: String, _arguments: Vec<ASTNode>) -> Result<ValueId, String> {
|
||||
fn build_new_expression(&mut self, class: String, arguments: Vec<ASTNode>) -> Result<ValueId, String> {
|
||||
// Special handling for StringBox - if it has a string literal argument,
|
||||
// treat it as a string constant, not a box creation
|
||||
if class == "StringBox" && arguments.len() == 1 {
|
||||
if let ASTNode::Literal { value: LiteralValue::String(s), .. } = &arguments[0] {
|
||||
// Just create a string constant
|
||||
let dst = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::Const {
|
||||
dst,
|
||||
value: ConstValue::String(s.clone()),
|
||||
})?;
|
||||
|
||||
// Create RefNew for the StringBox
|
||||
let string_box_dst = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::RefNew {
|
||||
dst: string_box_dst,
|
||||
box_val: dst,
|
||||
})?;
|
||||
|
||||
return Ok(string_box_dst);
|
||||
}
|
||||
}
|
||||
|
||||
// For Phase 6.1, we'll create a simple RefNew without processing arguments
|
||||
// In a full implementation, arguments would be used for constructor calls
|
||||
let dst = self.value_gen.next();
|
||||
@ -743,9 +821,9 @@ impl MirBuilder {
|
||||
let object_value = self.build_expression(object)?;
|
||||
let value_result = self.build_expression(value)?;
|
||||
|
||||
// Set the field using RefSet
|
||||
self.emit_instruction(MirInstruction::RefSet {
|
||||
reference: object_value,
|
||||
// Set the field using BoxFieldStore (Phase 8.5 new instruction)
|
||||
self.emit_instruction(MirInstruction::BoxFieldStore {
|
||||
box_val: object_value,
|
||||
field,
|
||||
value: value_result,
|
||||
})?;
|
||||
@ -809,11 +887,12 @@ impl MirBuilder {
|
||||
// Evaluate the expression
|
||||
let expression_value = self.build_expression(expression)?;
|
||||
|
||||
// Create a new Future with the evaluated expression as the initial value
|
||||
// Phase 2: Convert FutureNew to NewBox + BoxCall implementation
|
||||
let future_id = self.value_gen.next();
|
||||
self.emit_instruction(MirInstruction::FutureNew {
|
||||
self.emit_instruction(MirInstruction::NewBox {
|
||||
dst: future_id,
|
||||
value: expression_value,
|
||||
box_type: "FutureBox".to_string(),
|
||||
args: vec![expression_value],
|
||||
})?;
|
||||
|
||||
// Store the future in the variable
|
||||
@ -827,13 +906,16 @@ impl MirBuilder {
|
||||
// Evaluate the expression (should be a Future)
|
||||
let future_value = self.build_expression(expression)?;
|
||||
|
||||
// Create destination for await result
|
||||
// Phase 2: Convert Await to BoxCall implementation
|
||||
let result_id = self.value_gen.next();
|
||||
|
||||
// Emit await instruction
|
||||
self.emit_instruction(MirInstruction::Await {
|
||||
dst: result_id,
|
||||
future: future_value,
|
||||
// Emit await as a method call on the future box
|
||||
self.emit_instruction(MirInstruction::BoxCall {
|
||||
dst: Some(result_id),
|
||||
box_val: future_value,
|
||||
method: "await".to_string(),
|
||||
args: vec![],
|
||||
effects: EffectMask::IO.add(Effect::Control), // Await has IO and control effects
|
||||
})?;
|
||||
|
||||
Ok(result_id)
|
||||
|
||||
Reference in New Issue
Block a user