Early support for basic (non-capturing) closures: add closure detection, extraction, and lowering logic; update related modules and tests.

Author: IntegralPilot

.gitignore

@@ -5,7 +5,6 @@
 **/.gradle/*
 **/build/*
 **/.kotlin/*
-library/gradle/**
 
 # Files generated by Tester.py
 **/*.generated

src/lib.rs

@@ -49,6 +49,75 @@ mod optimise1;
 /// An instance of our Java bytecode codegen backend.
 struct MyBackend;
 
+/// Helper function to lower a closure definition to OOMIR
+///
+/// This function is called when we encounter a closure call and need to ensure
+/// the closure's implementation is available in the OOMIR module.
+fn lower_closure_to_oomir<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    closure_def_id: rustc_hir::def_id::DefId,
+    oomir_module: &mut oomir::Module,
+) {
+    // Generate the closure function name
+    let closure_name = lower1::generate_closure_function_name(tcx, closure_def_id);
+
+    // Check if we've already lowered this closure
+    if oomir_module.functions.contains_key(&closure_name) {
+        breadcrumbs::log!(
+            breadcrumbs::LogLevel::Info,
+            "closure-lowering",
+            format!("Closure {} already lowered, skipping", closure_name)
+        );
+        return;
+    }
+
+    breadcrumbs::log!(
+        breadcrumbs::LogLevel::Info,
+        "closure-lowering",
+        format!(
+            "Lowering closure: {} (DefId: {:?})",
+            closure_name, closure_def_id
+        )
+    );
+
+    // Get the closure's MIR using expect_resolve with fully monomorphized typing environment
+    // We use fully_monomorphized() since we've already filtered out closures with captures.
+    use rustc_middle::ty::TypingEnv;
+    let typing_env = TypingEnv::fully_monomorphized();
+    let generic_args = rustc_middle::ty::GenericArgs::empty();
+
+    let instance = rustc_middle::ty::Instance::expect_resolve(
+        tcx,
+        typing_env,
+        closure_def_id,
+        generic_args,
+        rustc_span::DUMMY_SP,
+    );
+
+    let mut mir = tcx.optimized_mir(instance.def_id()).clone();
+
+    breadcrumbs::log!(
+        breadcrumbs::LogLevel::Info,
+        "closure-lowering",
+        format!("Closure MIR for {}: {:?}", closure_name, mir)
+    );
+
+    // Lower the closure MIR to OOMIR, providing the closure name as an override
+    // since closures don't have proper item names in rustc
+    let (oomir_function, data_types) =
+        lower1::mir_to_oomir(tcx, instance, &mut mir, Some(closure_name.clone()));
+
+    breadcrumbs::log!(
+        breadcrumbs::LogLevel::Info,
+        "closure-lowering",
+        format!("Successfully lowered closure: {}", closure_name)
+    );
+
+    // Add the closure function to the module
+    oomir_module.functions.insert(closure_name, oomir_function);
+    oomir_module.merge_data_types(&data_types);
+}
+
 impl CodegenBackend for MyBackend {
     fn locale_resource(&self) -> &'static str {
         ""
@@ -69,6 +138,10 @@ impl CodegenBackend for MyBackend {
             data_types: std::collections::HashMap::new(),
         };
 
+        // Track closures we need to lower
+        let mut closures_to_lower: std::collections::HashSet<rustc_hir::def_id::DefId> =
+            std::collections::HashSet::new();
+
         // Iterate through all items in the crate and find functions
         let module_items = tcx.hir_crate_items(());
 
@@ -92,12 +165,45 @@ impl CodegenBackend for MyBackend {
                     format!("MIR for function {i}: {:?}", mir)
                 );
 
+                // Collect closures from mentioned_items in the MIR
+                if let Some(mentioned_items) = &mir.mentioned_items {
+                    for mentioned in mentioned_items.iter() {
+                        // Check if this mentioned item is a closure
+                        if let rustc_middle::mir::MentionedItem::Fn(fn_ty) = &mentioned.node {
+                            if let rustc_middle::ty::TyKind::FnDef(_fn_def_id, fn_args) =
+                                fn_ty.kind()
+                            {
+                                // Check the first argument to see if it's a closure type
+                                if let Some(first_arg) = fn_args.get(0) {
+                                    if let Some(ty) = first_arg.as_type() {
+                                        if let rustc_middle::ty::TyKind::Closure(
+                                            closure_def_id,
+                                            _,
+                                        ) = ty.kind()
+                                        {
+                                            breadcrumbs::log!(
+                                                breadcrumbs::LogLevel::Info,
+                                                "closure-discovery",
+                                                format!(
+                                                    "Found closure {:?} in function {}",
+                                                    closure_def_id, i
+                                                )
+                                            );
+                                            closures_to_lower.insert(*closure_def_id);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
                 breadcrumbs::log!(
                     breadcrumbs::LogLevel::Info,
                     "mir-lowering",
                     format!("--- Starting MIR to OOMIR Lowering for function: {i} ---")
                 );
-                let oomir_result = lower1::mir_to_oomir(tcx, instance, &mut mir);
+                let oomir_result = lower1::mir_to_oomir(tcx, instance, &mut mir, None);
                 breadcrumbs::log!(
                     breadcrumbs::LogLevel::Info,
                     "mir-lowering",
@@ -167,12 +273,43 @@ impl CodegenBackend for MyBackend {
                         format!("MIR for function {i2}: {:?}", mir)
                     );
 
+                    // Collect closures from mentioned_items in the MIR
+                    if let Some(mentioned_items) = &mir.mentioned_items {
+                        for mentioned in mentioned_items.iter() {
+                            if let rustc_middle::mir::MentionedItem::Fn(fn_ty) = &mentioned.node {
+                                if let rustc_middle::ty::TyKind::FnDef(_fn_def_id, fn_args) =
+                                    fn_ty.kind()
+                                {
+                                    if let Some(first_arg) = fn_args.get(0) {
+                                        if let Some(ty) = first_arg.as_type() {
+                                            if let rustc_middle::ty::TyKind::Closure(
+                                                closure_def_id,
+                                                _,
+                                            ) = ty.kind()
+                                            {
+                                                breadcrumbs::log!(
+                                                    breadcrumbs::LogLevel::Info,
+                                                    "closure-discovery",
+                                                    format!(
+                                                        "Found closure {:?} in impl method {}",
+                                                        closure_def_id, i2
+                                                    )
+                                                );
+                                                closures_to_lower.insert(*closure_def_id);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
                     breadcrumbs::log!(
                         breadcrumbs::LogLevel::Info,
                         "mir-lowering",
                         format!("--- Starting MIR to OOMIR Lowering for function: {i2} ---")
                     );
-                    let oomir_result = lower1::mir_to_oomir(tcx, instance, &mut mir);
+                    let oomir_result = lower1::mir_to_oomir(tcx, instance, &mut mir, None);
                     breadcrumbs::log!(
                         breadcrumbs::LogLevel::Info,
                         "mir-lowering",
@@ -566,6 +703,37 @@ impl CodegenBackend for MyBackend {
             }
         }
 
+        // Now lower all discovered closures
+        breadcrumbs::log!(
+            breadcrumbs::LogLevel::Info,
+            "closure-lowering",
+            format!(
+                "Attempting to lower {} discovered closures",
+                closures_to_lower.len()
+            )
+        );
+
+        for closure_def_id in closures_to_lower {
+            // Check if this closure captures any variables (has upvars)
+            // Closures that don't capture anything can be lowered with Instance::mono
+            let upvars = tcx.upvars_mentioned(closure_def_id);
+
+            if upvars.is_some() && !upvars.unwrap().is_empty() {
+                breadcrumbs::log!(
+                    breadcrumbs::LogLevel::Warn,
+                    "closure-lowering",
+                    format!(
+                        "Closure {} captures variables ({} upvars), skipping for now",
+                        lower1::generate_closure_function_name(tcx, closure_def_id),
+                        upvars.unwrap().len()
+                    )
+                );
+                continue;
+            }
+
+            lower_closure_to_oomir(tcx, closure_def_id, &mut oomir_module);
+        }
+
         breadcrumbs::log!(
             breadcrumbs::LogLevel::Info,
             "backend",
@@ -714,7 +882,7 @@ impl CodegenBackend for MyBackend {
 
 struct RustcCodegenJvmLogListener;
 
-const LISTENING_CHANNELS: &[&str] = &["backend"];
+const LISTENING_CHANNELS: &[&str] = &[];
 
 impl breadcrumbs::LogListener for RustcCodegenJvmLogListener {
     fn on_log(&mut self, log: breadcrumbs::Log) {

src/lower1.rs

@@ -16,26 +16,47 @@ use rustc_middle::{
 use std::collections::HashMap;
 use types::ty_to_oomir_type;
 
+mod closures;
 mod control_flow;
 pub mod operand;
 pub mod place;
 pub mod types;
 
+pub use closures::{ClosureCallInfo, extract_closure_info, generate_closure_function_name};
+
 /// Converts a MIR Body into an OOMIR Function.
-/// This function extracts a function’s signature (currently minimal) and builds
+/// This function extracts a function's signature (currently minimal) and builds
 /// a control flow graph of basic blocks.
+///
+/// If `fn_name_override` is provided, it will be used as the function name instead of
+/// querying rustc for the item name. This is necessary for closures, which don't have
+/// proper item names in rustc's internal representation.
 pub fn mir_to_oomir<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
     mir: &mut Body<'tcx>,
+    fn_name_override: Option<String>,
 ) -> (oomir::Function, HashMap<String, oomir::DataType>) {
-    // Get a function name from the instance.
-    let fn_name = tcx.item_name(instance.def_id()).to_string();
+    use rustc_middle::ty::TyKind;
+
+    // Get a function name from the instance or use the provided override.
+    // Closures don't have proper item names, so we must use an override for them.
+    let fn_name = fn_name_override.unwrap_or_else(|| tcx.item_name(instance.def_id()).to_string());
 
     // Extract function signature
-    let mir_sig = tcx.type_of(instance.def_id()).skip_binder().fn_sig(tcx);
-    let params_ty = mir_sig.inputs();
-    let return_ty = mir_sig.output();
+    // Closures require special handling - we must use as_closure().sig() instead of fn_sig()
+    let instance_ty = tcx.type_of(instance.def_id()).skip_binder();
+    let (params_ty, return_ty) = match instance_ty.kind() {
+        TyKind::Closure(_def_id, args) => {
+            let sig = args.as_closure().sig();
+            (sig.inputs(), sig.output())
+        }
+        _ => {
+            // Regular function - use fn_sig()
+            let mir_sig = instance_ty.fn_sig(tcx);
+            (mir_sig.inputs(), mir_sig.output())
+        }
+    };
 
     let data_types = &mut HashMap::new();
 
@@ -89,42 +110,48 @@ pub fn mir_to_oomir<'tcx>(
         basic_blocks.insert(bb_ir.label.clone(), bb_ir);
     }
 
-    /*let mut instrs = vec![];
-
-    // Initialize local variables (excluding return place and arguments)
-    // MIR local indices:
-    // 0: return place
-    // 1..=arg_count: arguments
-    // arg_count+1..: user variables and temporaries
-    for (local_index, local_decl) in mir_cloned.local_decls.iter_enumerated() {
-        // local_index has type Local
-        // local_decl has type &LocalDecl<'tcx>
-
-        // Skip return place (_0) and arguments (_1 to _arg_count)
-        // They are initialized by return value / function call respectively.
-        if local_index.index() == 0 || local_index.index() <= mir_cloned.arg_count {
-            continue; // Skip this local
-        }
-
-        let ty = local_decl.ty;
-        let oomir_ty = ty_to_oomir_type(ty, tcx, data_types);
-
-        // Only add initialization if the type has a default value we can represent
-        let default = oomir_ty.get_default_value(data_types);
-        if default.is_none() {
-            continue;
+    // For closures, we need to unpack the tuple argument into local variables
+    // Closures take a single tuple parameter, but MIR expects individual arguments in separate locals
+    let mut instrs = vec![];
+
+    if matches!(instance_ty.kind(), TyKind::Closure(..)) && mir_cloned.arg_count > 0 {
+        // For closures: local 0 = return place, local 1 = tuple argument
+        // MIR expects: local 0 = return, local 1 = first arg, local 2 = second arg, etc.
+        // But we receive: local 1 = tuple containing all args
+
+        // Get the tuple parameter type (should be the first parameter in the signature)
+        if let Some(tuple_param_ty) = signature.params.first() {
+            // Check if it's a tuple/struct type that we need to unpack
+            if let oomir::Type::Class(class_name) = tuple_param_ty {
+                // Get the data type definition to see its fields
+                if let Some(oomir::DataType::Class { fields, .. }) = data_types.get(class_name) {
+                    // Unpack each field from the tuple into the expected local variables
+                    // Local 1 contains the tuple, we need to extract fields to locals 2, 3, 4...
+                    for (field_idx, (field_name, field_ty)) in fields.iter().enumerate() {
+                        let local_var_index = field_idx + 2; // Start from local 2 (local 1 is the tuple)
+
+                        // Get the field from the tuple object (local 1)
+                        instrs.push(oomir::Instruction::GetField {
+                            dest: format!("_{}", local_var_index),
+                            object: oomir::Operand::Variable {
+                                name: "_1".to_string(),
+                                ty: tuple_param_ty.clone(),
+                            },
+                            field_name: field_name.clone(),
+                            field_ty: field_ty.clone(),
+                            owner_class: class_name.clone(),
+                        });
+                    }
+                }
+            }
         }
-        // Get the underlying usize index for formatting
-        let idx_usize = local_index.index();
-        instrs.push(Instruction::Move {
-            dest: format!("_{}", idx_usize),
-            src: Operand::Constant(default.unwrap()),
-        });
     }
 
     // add instrs to the start of the entry block
-    let entry_block = basic_blocks.get_mut(&entry_label).unwrap();
-    entry_block.instructions.splice(0..0, instrs);*/
+    if !instrs.is_empty() {
+        let entry_block = basic_blocks.get_mut(&entry_label).unwrap();
+        entry_block.instructions.splice(0..0, instrs);
+    }
 
     let codeblock = oomir::CodeBlock {
         basic_blocks,