Support for mutable borrows (&mut).

Uses a cool trick with JVM arrays to get it work. Includes new integration test. Also in a previous commit accidentally replaced the ops test with a simpler version, restored it.

Author: IntegralPilot

Readme.md

@@ -49,6 +49,8 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 - Arrays & slices with nested indexing  
 - Structs, tuples, enums (both C‑like and Rust‑style)  
 - Executable `.jar` generation for binary crates  
+- Mutable borrowing, references, and dereferencing
+- **Integration tests** for all features
 
 🚧 **Next Milestone:** Full support for the Rust `core` crate.
 

src/lower1/control_flow.rs

@@ -10,7 +10,7 @@ use crate::oomir;
 
 use rustc_middle::{
     mir::{
-        BasicBlock, BasicBlockData, Body, Operand as MirOperand, Place, StatementKind,
+        BasicBlock, BasicBlockData, Body, Local, Operand as MirOperand, Place, StatementKind,
         TerminatorKind,
     },
     ty::TyCtxt,
@@ -33,6 +33,8 @@ pub fn convert_basic_block<'tcx>(
     // Use the basic block index as its label.
     let label = format!("bb{}", bb.index());
     let mut instructions = Vec::new();
+    let mut mutable_borrow_arrays: HashMap<Local, (Place<'tcx>, String, oomir::Type)> =
+        HashMap::new();
 
     // Convert each MIR statement in the block.
     for stmt in &bb_data.statements {
@@ -48,6 +50,53 @@ pub fn convert_basic_block<'tcx>(
                 // Add instructions needed to calculate the Rvalue
                 instructions.extend(rvalue_instructions);
 
+                if let rustc_middle::mir::Rvalue::Ref(
+                    _,
+                    rustc_middle::mir::BorrowKind::Mut { .. },
+                    borrowed_place,
+                ) = rvalue
+                {
+                    // Check if the destination is a simple local (most common case for &mut assignment)
+                    if place.projection.is_empty() {
+                        if let oomir::Operand::Variable {
+                            name: array_var_name,
+                            ty: array_ty,
+                        } = &source_operand
+                        {
+                            // Extract element type from array type
+                            if let oomir::Type::MutableReference(element_ty) = array_ty {
+                                println!(
+                                    "Info: Tracking mutable borrow array for place {:?} stored in local {:?}. Original: {:?}, ArrayVar: {}, ElementTy: {:?}",
+                                    place, place.local, borrowed_place, array_var_name, element_ty
+                                );
+                                mutable_borrow_arrays.insert(
+                                    place.local, // The local holding the array reference (e.g., _3)
+                                    (
+                                        borrowed_place.clone(), // The original place borrowed (e.g., _1)
+                                        array_var_name.clone(), // The OOMIR name of the array var (e.g., "3_tmp0")
+                                        *element_ty.clone(), // The type of the element in the array
+                                    ),
+                                );
+                            } else {
+                                println!(
+                                    "Warning: Expected type for mutable borrow ref, found {:?}",
+                                    array_ty
+                                );
+                            }
+                        } else {
+                            println!(
+                                "Warning: Expected variable operand for mutable borrow ref assignment result, found {:?}",
+                                source_operand
+                            );
+                        }
+                    } else {
+                        println!(
+                            "Warning: Mutable borrow assigned to complex place {:?}, write-back might not work correctly.",
+                            place
+                        );
+                    }
+                }
+
                 // 2. Generate instructions to store the computed value into the destination place
                 let assignment_instructions = emit_instructions_to_set_value(
                     place,          // The actual destination Place
@@ -158,25 +207,110 @@ pub fn convert_basic_block<'tcx>(
             } => {
                 println!("the function name is {:?}", func);
                 let function_name = make_jvm_safe(format!("{:?}", func).as_str()); // Get function name - needs refinement to extract actual name
-                let oomir_args = args
-                    .iter()
-                    .map(|arg| convert_operand(&arg.node, tcx, mir, data_types, &mut instructions))
-                    .collect();
-                let dest = Some(format!("{:?}", destination.local));
 
+                // --- Track Argument Origins ---
+                // Store tuples: (Maybe Original MIR Place of Arg, OOMIR Operand for Arg)
+                let mut processed_args: Vec<(Option<Place<'tcx>>, oomir::Operand)> = Vec::new();
+                let mut pre_call_instructions = Vec::new(); // Instructions needed *before* the call for args
+
+                for arg in args {
+                    let mir_op = &arg.node;
+                    // Important: Pass pre_call_instructions here to collect setup code for this arg
+                    let oomir_op =
+                        convert_operand(mir_op, tcx, mir, data_types, &mut pre_call_instructions);
+
+                    // Identify if the MIR operand is a direct use of a local Place
+                    let maybe_arg_place = match mir_op {
+                        MirOperand::Move(p) | MirOperand::Copy(p) if p.projection.is_empty() => {
+                            Some(p.clone())
+                        }
+                        _ => None,
+                    };
+                    processed_args.push((maybe_arg_place, oomir_op));
+                }
+                // Add instructions needed to prepare arguments *before* the call
+                instructions.extend(pre_call_instructions);
+
+                // Collect just the OOMIR operands for the call itself
+                let oomir_args: Vec<oomir::Operand> =
+                    processed_args.iter().map(|(_, op)| op.clone()).collect();
+
+                // Determine destination OOMIR variable name (if any)
+                let dest_var_name = destination.projection.is_empty()
+                    .then(|| format!("_{}", destination.local.index()))
+                    .or_else(|| {
+                         println!("Warning: Call destination {:?} is complex, return value might be lost.", destination);
+                         None // Handle complex destinations if needed later
+                    });
+
+                // --- Emit the Call Instruction ---
                 instructions.push(oomir::Instruction::Call {
-                    dest,
+                    dest: dest_var_name,
                     function: function_name,
                     args: oomir_args,
                 });
 
+                let mut write_back_instrs = Vec::new();
+                for (maybe_arg_place, oomir_arg_operand) in &processed_args {
+                    if let Some(arg_place) = maybe_arg_place {
+                        // Check if the local used for this argument is one we tracked as a mutable borrow array
+                        if let Some((original_place, array_var_name, element_ty)) =
+                            mutable_borrow_arrays.get(&arg_place.local)
+                        {
+                            // Double-check if the operand passed was indeed the variable we expected
+                            if let oomir::Operand::Variable {
+                                name: passed_var_name,
+                                ..
+                            } = oomir_arg_operand
+                            {
+                                println!(
+                                    "Info: Emitting write-back for mutable borrow. Arg Place: {:?}, Original Place: {:?}, Array Var: {}",
+                                    arg_place, original_place, array_var_name
+                                );
+
+                                // Create a temporary variable for the value read from the array
+                                let temp_writeback_var =
+                                    format!("_writeback_{}", original_place.local.index());
+
+                                // 1. Get value from array (using the tracked array_var_name)
+                                let array_operand = oomir::Operand::Variable {
+                                    name: array_var_name.clone(),
+                                    // Reconstruct array type for clarity (though not strictly needed by ArrayGet)
+                                    ty: oomir::Type::Array(Box::new(element_ty.clone())),
+                                };
+                                write_back_instrs.push(oomir::Instruction::ArrayGet {
+                                    dest: temp_writeback_var.clone(),
+                                    array: array_operand,
+                                    index: oomir::Operand::Constant(oomir::Constant::I32(0)), // Always index 0
+                                });
+
+                                // 2. Set value back to original place
+                                let value_to_set = oomir::Operand::Variable {
+                                    name: temp_writeback_var,
+                                    ty: element_ty.clone(), // Use the tracked element type
+                                };
+                                let set_instrs = emit_instructions_to_set_value(
+                                    original_place, // The original Place (_1)
+                                    value_to_set,   // The value read from the array
+                                    tcx,
+                                    mir,
+                                    data_types,
+                                );
+                                write_back_instrs.extend(set_instrs);
+                            }
+                        }
+                    }
+                }
+                instructions.extend(write_back_instrs);
+
+                // --- Add Jump to Target Block (if call returns) ---
                 if let Some(target_bb) = target {
                     let target_label = format!("bb{}", target_bb.index());
                     println!(
                         "Info: Adding Jump to {} after Call in bb{}",
                         target_label,
                         bb.index()
-                    ); // Add log
+                    );
                     instructions.push(oomir::Instruction::Jump {
                         target: target_label,
                     });

src/lower1/control_flow/rvalue.rs

@@ -1,6 +1,6 @@
 use rustc_abi::FieldIdx;
 use rustc_middle::{
-    mir::{BinOp, Body, Operand as MirOperand, Place, Rvalue, UnOp},
+    mir::{BinOp, Body, BorrowKind as MirBorrowKind, Operand as MirOperand, Place, Rvalue, UnOp},
     ty::{ConstKind, TyCtxt, TyKind, inherent::ValueConst},
 };
 use std::collections::HashMap;
@@ -117,17 +117,87 @@ pub fn convert_rvalue_to_operand<'a>(
                 result_operand = get_placeholder_operand(original_dest_place, mir, tcx, data_types);
             }
         }
+        Rvalue::Ref(_region, borrow_kind, source_place) => {
+            match borrow_kind {
+                MirBorrowKind::Mut { .. } => {
+                    // --- MUTABLE BORROW (&mut T) -> Use Array Hack ---
+                    println!(
+                        "Info: Handling Rvalue::Ref(Mut) for place '{}' -> Temp Array Var",
+                        place_to_string(source_place, tcx)
+                    );
 
-        Rvalue::Ref(_region, _borrow_kind, source_place) => {
-            // In many Java-like backends, a reference is often represented by the
-            // value/object itself. Let's assume that for now.
-            let (temp_var_name, get_instructions, temp_var_type) =
-                emit_instructions_to_get_on_own(source_place, tcx, mir, data_types);
-            instructions.extend(get_instructions);
-            result_operand = oomir::Operand::Variable {
-                name: temp_var_name,
-                ty: temp_var_type, // Or potentially wrap in Ref type if needed
-            };
+                    // 1. Get the value of the place being referenced (the 'pointee').
+                    let (pointee_value_var_name, pointee_get_instructions, pointee_oomir_type) =
+                        emit_instructions_to_get_on_own(source_place, tcx, mir, data_types);
+                    instructions.extend(pointee_get_instructions); // Add instructions to get the value
+
+                    // 2. Determine the OOMIR type for the array reference itself.
+                    let array_ref_oomir_type =
+                        oomir::Type::MutableReference(Box::new(pointee_oomir_type.clone()));
+
+                    // 3. Create a temporary variable name for the new array.
+                    let array_ref_var_name = generate_temp_var_name(&base_temp_name);
+
+                    // 4. Emit instruction to allocate the single-element array (new T[1]).
+                    instructions.push(oomir::Instruction::NewArray {
+                        dest: array_ref_var_name.clone(),
+                        element_type: pointee_oomir_type.clone(),
+                        size: oomir::Operand::Constant(oomir::Constant::I32(1)),
+                    });
+
+                    // 5. Emit instruction to store the pointee's value into the array's first element.
+                    let pointee_value_operand = oomir::Operand::Variable {
+                        name: pointee_value_var_name,
+                        ty: pointee_oomir_type,
+                    };
+                    instructions.push(oomir::Instruction::ArrayStore {
+                        array: array_ref_var_name.clone(),
+                        index: oomir::Operand::Constant(oomir::Constant::I32(0)),
+                        value: pointee_value_operand,
+                    });
+
+                    // 6. The result is the reference to the newly created array.
+                    result_operand = oomir::Operand::Variable {
+                        name: array_ref_var_name,
+                        ty: array_ref_oomir_type,
+                    };
+                    println!(
+                        "Info: -> Temp Array Var '{}' ({:?})",
+                        result_operand.get_name().unwrap_or("<unknown>"),
+                        result_operand.get_type()
+                    );
+                }
+
+                MirBorrowKind::Shared | MirBorrowKind::Fake { .. } => {
+                    // Treat Fake like Shared (used for closures etc.)
+                    // --- SHARED BORROW (&T) or others -> Pass Through Value ---
+                    println!(
+                        "Info: Handling Rvalue::Ref({:?}) for place '{}' -> Direct Value",
+                        borrow_kind,
+                        place_to_string(source_place, tcx)
+                    );
+
+                    // 1. Get the value/reference of the place being borrowed directly.
+                    //    `emit_instructions_to_get_on_own` handles loading/accessing the value.
+                    let (pointee_value_var_name, pointee_get_instructions, pointee_oomir_type) =
+                        emit_instructions_to_get_on_own(source_place, tcx, mir, data_types);
+
+                    // 2. Add the instructions needed to get this value.
+                    instructions.extend(pointee_get_instructions);
+
+                    // 3. The result *is* the operand representing the borrowed value itself.
+                    //    No array wrapping is done.
+                    result_operand = oomir::Operand::Variable {
+                        name: pointee_value_var_name,
+                        ty: pointee_oomir_type,
+                    };
+                    println!(
+                        "Info: -> Direct Value Operand '{}' ({:?})",
+                        result_operand.get_name().unwrap_or("<unknown>"),
+                        result_operand.get_type()
+                    );
+                }
+            }
         }
 
         Rvalue::Len(source_place) => {
@@ -795,6 +865,13 @@ pub fn convert_rvalue_to_operand<'a>(
                         panic!("Discriminant on Ref to non-class type: {:?}", inner)
                     }
                 }
+                oomir::Type::MutableReference(inner) => {
+                    if let oomir::Type::Class(name) = inner.as_ref() {
+                        name.clone()
+                    } else {
+                        panic!("Discriminant on MutableRef to non-class type: {:?}", inner)
+                    }
+                }
                 _ => panic!(
                     "Discriminant on non-class type: {:?}",
                     actual_value_oomir_type

src/lower1/operand.rs

@@ -1070,14 +1070,50 @@ pub fn handle_const_value<'tcx>(
         }
         ConstValue::ZeroSized => {
             println!("Info: Encountered ZeroSized constant for type {:?}", ty);
-            oomir::Operand::Constant(oomir::Constant::I32(0)) // Placeholder
+            oomir::Operand::Constant(oomir::Constant::I32(0))
         }
-        ConstValue::Indirect {
-            alloc_id: _,
-            offset: _,
-        } => {
-            println!("Warning: Indirect constants not fully handled yet.");
-            oomir::Operand::Constant(oomir::Constant::I32(0)) // Placeholder
+        ConstValue::Indirect { alloc_id, offset } => {
+            println!(
+                "Info: Handling Indirect constant (AllocId: {:?}, Offset: {:?}, Type: {:?})",
+                alloc_id, offset, ty
+            );
+            // Get the allocation where the constant data resides
+            match tcx.global_alloc(alloc_id) {
+                rustc_middle::mir::interpret::GlobalAlloc::Memory(const_allocation) => {
+                    let allocation = const_allocation.inner();
+                    // Use the dedicated function to read the value from memory
+                    match read_constant_value_from_memory(
+                        tcx, allocation,
+                        offset, // The offset provided by ConstValue::Indirect
+                        *ty,    // The type of the constant we are reading
+                        data_types,
+                    ) {
+                        Ok(oomir_const) => {
+                            println!(
+                                "Info: Successfully extracted indirect constant: {:?}",
+                                oomir_const
+                            );
+                            oomir::Operand::Constant(oomir_const)
+                        }
+                        Err(e) => {
+                            println!(
+                                "Error: Failed to read indirect constant of type {:?} from allocation {:?}: {}",
+                                ty, alloc_id, e
+                            );
+                            // Return an error placeholder, maybe distinct from other errors
+                            oomir::Operand::Constant(oomir::Constant::I64(-60))
+                        }
+                    }
+                }
+                other_alloc => {
+                    // This case should be rare for constants defined in code, but handle it defensively.
+                    println!(
+                        "Warning: Indirect constant points to unexpected GlobalAlloc kind: {:?}. AllocId: {:?}, Type: {:?}",
+                        other_alloc, alloc_id, ty
+                    );
+                    oomir::Operand::Constant(oomir::Constant::I64(-61))
+                }
+            }
         }
     }
 }