Support for impl blocks, and new test confirming this.

Author: IntegralPilot

Readme.md

@@ -32,6 +32,7 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 - **[Collatz conjecture](tests/binary/collatz/src/main.rs)** verifier  
 - **[Large prime](tests/binary/primes/src/main.rs)** generator  
 - Use of nested data structures: enums, structs, tuples, arrays, slices (**[enums](tests/binary/enums/src/main.rs)**, **[structs](tests/binary/structs/src/main.rs)** - both tests use arrays and tuples)  
+* **[Implementation blocks](tests/binary/impl/src/main.rs)**
 - …and more!
 
 ---
@@ -50,6 +51,7 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 - Structs, tuples, enums (both C‑like and Rust‑style)  
 - Executable `.jar` generation for binary crates  
 - Mutable borrowing, references, and dereferencing
+- Implementations for ADTs, including using and returning `self`, `&self`, `&mut self`
 - **Integration tests** for all features, in debug and release modes
 
 🚧 **Next Milestone:** Full support for the Rust `core` crate.

Tester.py

@@ -45,6 +45,8 @@ def process_test(test_dir: str, release_mode: bool):
         output = f"STDOUT:\n{proc.stdout}\n\nSTDERR:\n{proc.stderr}"
         write_to_file(fail_path, output)
         print(f"|---- ❌ cargo build exited with code {proc.returncode}")
+        print(f"|---- STDERR:")
+        print(proc.stderr)
         return False
 
     print("|--- 🤖 Running with Java...")

src/lib.rs

@@ -31,6 +31,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_metadata::EncodedMetadata;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_middle::ty::TyCtxt;
+use rustc_hir::{TyKind as HirTyKind, QPath};
 use rustc_session::{Session, config::OutputFilenames};
 use std::{any::Any, io::Write, path::Path};
 
@@ -96,6 +97,55 @@ impl CodegenBackend for MyBackend {
                     .insert(oomir_function.name.clone(), oomir_function);
 
                 oomir_module.merge_data_types(&oomir_result.1);
+            } else if let rustc_hir::ItemKind::Impl(impl_a) = item.kind {
+                let ident = match impl_a.self_ty.kind {
+                    HirTyKind::Path(qpath) => {
+                        match qpath {
+                            QPath::Resolved(_, p) => {
+                                format!("{}", p.segments[0].ident)
+                            }
+                            QPath::TypeRelative(_, ps) => {
+                                format!("{}", ps.ident)
+                            }
+                            _ => {
+                                println!("Warning: {:?} is an unknown qpath", qpath);
+                                "unknown_qpath_kind".into()
+                            }
+                        }
+                    }
+                    _ => {
+                        println!("Warning: {:?} has unknown kind", impl_a.self_ty);
+                        "unknown_type_kind".into()
+                    }
+                };
+                for item in impl_a.items {
+                    let i = item.ident;
+                    let def_id = item.id.owner_id.to_def_id();
+
+                    if tcx.generics_of(def_id).count() != 0 {
+                        println!("Skipping generic impl: {i}");
+                        continue; // Skip generic functions for now
+                    }
+                    let instance = rustc_middle::ty::Instance::mono(tcx, def_id);
+                    let mut mir = tcx.optimized_mir(instance.def_id()).clone(); // Clone the MIR
+
+                    let i = format!("{}_{}", ident, i).to_lowercase();
+    
+                    println!("MIR for function {i}: {:?}", mir);
+    
+                    println!("--- Starting MIR to OOMIR Lowering for function: {i} ---");
+                    let oomir_result = lower1::mir_to_oomir(tcx, instance, &mut mir);
+                    println!("--- Finished MIR to OOMIR Lowering for function: {i} ---");
+    
+                    let mut oomir_function = oomir_result.0;
+                    oomir_function.name = i.clone();
+    
+                    oomir_module
+                        .functions
+                        .insert(i, oomir_function);
+    
+                    oomir_module.merge_data_types(&oomir_result.1);
+                }
             }
         }
 

src/lower1/control_flow.rs

@@ -440,6 +440,9 @@ pub fn convert_basic_block<'tcx>(
                     rustc_middle::mir::AssertKind::NullPointerDereference => {
                         "NullPointerDereference".to_string()
                     }
+                    rustc_middle::mir::AssertKind::ResumedAfterDrop(_) => {
+                        "ResumedAfterDrop".to_string()
+                    }
                 };
 
                 let fail_instructions = vec![oomir::Instruction::ThrowNewWithMessage {
@@ -465,6 +468,8 @@ pub fn convert_basic_block<'tcx>(
                 target,
                 unwind: _,
                 replace: _,
+                drop: _,
+                async_fut: _
             } => {
                 // In simple cases (no custom Drop trait), a MIR drop often just signifies
                 // the end of a scope before control flow continues.

tests/binary/enums/src/main.rs

@@ -1,11 +1,11 @@
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq)]
 struct ConfigData {
     id: u32,
     enabled: bool,
     params: (f32, f32), // Nested tuple
 }
 
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq)]
 enum ComplexEnum<'a> {
     SimpleVariant,                      // No data
     Count(i64),                         // Single primitive data

tests/binary/impl/.cargo/config.toml

@@ -0,0 +1 @@
+../../../../config.toml

tests/binary/impl/Cargo.lock

@@ -0,0 +1,8 @@
+cargo-features = ["profile-rustflags"]
+
+[package]
+name = "impl"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]