Implement full support for enums (C-like), including a new test.

Support for them having anonymous structs or tuples is coming in the next commit. :)

Author: IntegralPilot

Readme.md

@@ -43,7 +43,7 @@ This backend currently supports a subset of Rust features:
 *   ✅ Variable assignment including subfield and array index assignment, including nesting.
 *   ✅ Arrays and slices, including inserting, accessing and mutating at a given index (supporting nesting).
 *   ✅ Floats (`f32`, `f64`).
-*   ✅ Structs and Tuples (enums and unions coming soon!) including nesting access/setting/mutation of fields.
+*   ✅ Structs, Tuples and Enums (currently only C-like enums, no anonymous structs or tuples yet) including nesting access/setting/mutation of fields.
 *   ✅ Generating executable `.jar` files for binary crates.
 
 ### Next Milestone:

src/lower1/control_flow.rs

@@ -353,7 +353,13 @@ pub fn convert_basic_block<'tcx>(
                     target: target_label,
                 });
             }
-            // Other terminator kinds (like Resume, etc.) can be added as needed.
+            TerminatorKind::Unreachable => {
+                instructions.push(oomir::Instruction::ThrowNewWithMessage {
+                    exception_class: "java/lang/RuntimeException".to_string(),
+                    message: "Unreachable code reached".to_string(),
+                });
+            }
+            // Other terminator kinds (like Resume, etc.) will be added as needed.
             _ => {
                 println!("Warning: Unhandled terminator {:?}", terminator.kind);
             }

src/lower1/control_flow/rvalue.rs

@@ -1,3 +1,4 @@
+use rustc_abi::FieldIdx;
 use rustc_middle::{
     mir::{BinOp, Body, Operand as MirOperand, Place, Rvalue, UnOp},
     ty::{ConstKind, TyCtxt, TyKind, inherent::ValueConst},
@@ -655,6 +656,30 @@ pub fn convert_rvalue_to_operand<'a>(
                         }
 
                         // Construct the enum variant object
+                        instructions.push(oomir::Instruction::ConstructObject {
+                            dest: temp_aggregate_var.clone(),
+                            class_name: variant_class_name.clone(),
+                        });
+
+                        // Set fields
+                        for (i, field) in variant_def.fields.iter().enumerate() {
+                            let field_name = format!("field{}", i);
+                            let field_mir_ty = field.ty(tcx, substs);
+                            let field_oomir_type = ty_to_oomir_type(field_mir_ty, tcx, data_types);
+                            let value_operand = convert_operand(
+                                &operands[FieldIdx::from_usize(i)],
+                                tcx,
+                                mir,
+                                data_types,
+                            );
+                            instructions.push(oomir::Instruction::SetField {
+                                object_var: temp_aggregate_var.clone(),
+                                field_name,
+                                value: value_operand,
+                                field_ty: field_oomir_type,
+                                owner_class: variant_class_name.clone(),
+                            });
+                        }
                     } else {
                         // Union
                         println!("Warning: Unhandled ADT Aggregate Kind -> Temp Placeholder");
@@ -726,7 +751,46 @@ pub fn convert_rvalue_to_operand<'a>(
                 }
             }
         }
+        Rvalue::Discriminant(place) => {
+            // get the discriminate of the place (usually an enum)
+            // so basically just call `getVariantIdx` on the class in the place
+
+            let place_name = place_to_string(place, tcx);
+            let place_type = get_place_type(place, mir, tcx, data_types);
+
+            let temp_discriminant_var = generate_temp_var_name(&base_temp_name);
+            let place_class_name = match place_type.clone() {
+                oomir::Type::Class(name) => name.clone(),
+                _ => panic!("Discriminant on non-class type {:?}", place),
+            };
+            let place_class = data_types.get(&place_class_name).unwrap();
+            let method_name = "getVariantIdx".to_string();
+            let method_return_tuple = place_class.methods.get(&method_name).unwrap();
+            let method_return_type = method_return_tuple.0.clone();
+
+            let method_ty = oomir::Signature {
+                params: vec![],
+                ret: Box::new(method_return_type.clone()),
+            };
 
+            // we can InvokeStatic as lower2 makes the field index method static (it doesn't depend on fields at all)
+            instructions.push(oomir::Instruction::InvokeVirtual {
+                class_name: place_class_name.clone(),
+                method_name,
+                args: vec![],
+                dest: Some(temp_discriminant_var.clone()),
+                method_ty,
+                operand: oomir::Operand::Variable {
+                    name: place_name,
+                    ty: place_type,
+                },
+            });
+
+            result_operand = oomir::Operand::Variable {
+                name: temp_discriminant_var,
+                ty: method_return_type,
+            };
+        }
         // Handle other Rvalue variants by generating a placeholder
         _ => {
             println!(

src/lower1/types.rs

@@ -215,7 +215,7 @@ pub fn mir_int_to_oomir_const<'tcx>(
             IntTy::I16 => oomir::Constant::I16(value as i16), // Be careful
             IntTy::I32 => oomir::Constant::I32(value as i32), // Be careful
             IntTy::I64 => oomir::Constant::I64(value as i64),
-            IntTy::Isize => oomir::Constant::I64(value as i64), // Assuming 64-bit target
+            IntTy::Isize => oomir::Constant::I32(value as i32), // JVM uses i32 for most "usize" tasks
             IntTy::I128 => oomir::Constant::I64(value as i64), // Truncate for JVM compatibility? Or error?
         },
         TyKind::Uint(uint_ty) => match uint_ty {

src/lower2.rs

@@ -131,7 +131,7 @@ pub fn oomir_to_jvm_bytecode(
         let dt_bytecode = create_data_type_classfile(
             &dt_name_oomir,
             data_type,
-            "java/lang/Object", // Superclass
+            data_type.super_class.as_deref().unwrap_or("java/lang/Object"),
         )?;
         generated_classes.insert(dt_name_oomir.clone(), dt_bytecode);
     }

src/lower2/jvm_gen.rs

@@ -89,13 +89,7 @@ pub(super) fn create_data_type_classfile(
 
     let this_class_index = cp.add_class(class_name_jvm)?;
 
-    let super_class_from_data_type = &data_type.super_class;
-    let super_class_index;
-    if let Some(super_class) = super_class_from_data_type {
-        super_class_index = cp.add_class(super_class)?;
-    } else {
-        super_class_index = cp.add_class(super_class_name_jvm)?;
-    }
+    let super_class_index = cp.add_class(super_class_name_jvm)?;
 
     // --- Create Fields ---
     let mut fields: Vec<jvm::Field> = Vec::new();
@@ -165,7 +159,6 @@ pub(super) fn create_data_type_classfile(
 
         let jvm_method = jvm::Method {
             access_flags: MethodAccessFlags::PUBLIC
-                | MethodAccessFlags::STATIC
                 | if is_abstract {
                     MethodAccessFlags::ABSTRACT
                 } else {

src/lower2/translator.rs

@@ -1613,6 +1613,50 @@ impl<'a, 'cp> FunctionTranslator<'a, 'cp> {
                 //    The type for storage is the new type (ty)
                 self.store_result(dest, ty)?; // Stack: []
             }
+
+            OI::InvokeVirtual {
+                dest,
+                class_name,
+                method_name,
+                method_ty,
+                args,
+                operand,
+            } => {
+                // 1. Add Method reference to constant pool
+                let class_index = self.constant_pool.add_class(class_name)?;
+                let method_ref_index = self.constant_pool.add_method_ref(
+                    class_index,
+                    method_name,
+                    &method_ty.to_string(),
+                )?;
+
+                // 2. Load arguments onto the stack
+                for arg in args {
+                    self.load_call_argument(arg)?; // Use helper to handle references properly
+                }
+
+                // 3. Load the object reference (self) onto the stack
+                // The object reference is the first argument for instance methods
+                self.load_operand(operand)?; // Stack: [object_ref, args...]
+
+                // 4. Emit 'invokevirtual' instruction
+                self.jvm_instructions
+                    .push(JI::Invokevirtual(method_ref_index)); // Stack: [result]
+                // Note: The result type is determined by the method signature
+
+                // 5. Handle the return value
+                if let Some(dest_var) = dest {
+                    // Store the result in the destination variable
+                    self.store_result(dest_var, &method_ty.ret)?;
+                } else if *method_ty.ret.as_ref() != oomir::Type::Void {
+                    // Pop the result if it's not void and no destination is provided
+                    match get_type_size(&method_ty.ret) {
+                        1 => self.jvm_instructions.push(JI::Pop),
+                        2 => self.jvm_instructions.push(JI::Pop2),
+                        _ => {}
+                    }
+                }
+            }
         }
         Ok(())
     }

src/oomir.rs

@@ -240,6 +240,14 @@ pub enum Instruction {
         ty: Type,
         dest: String, // Destination variable for the casted value
     },
+    InvokeVirtual {
+        dest: Option<String>, // Optional destination variable for the return value
+        class_name: String,   // JVM class name (e.g., MyStruct)
+        method_name: String,  // Name of the method to call
+        method_ty: Signature, // Signature of the method (input/output types)
+        args: Vec<Operand>,   // Arguments to the function
+        operand: Operand,     // The object reference (this) for the method call
+    },
 }
 
 #[derive(Debug, Clone)]

tests/binary/enums/.cargo/config.toml

@@ -0,0 +1,13 @@
+[build]
+rustflags = [
+  "-Z", "codegen-backend=/Users/mreeve27/rustc_codegen_jvm/target/debug/librustc_codegen_jvm.dylib",
+  "-C", "linker=/Users/mreeve27/rustc_codegen_jvm/java-linker/target/debug/java-linker",
+  "-C", "link-args=/Users/mreeve27/rustc_codegen_jvm/library/build/distributions/library-0.1.0/lib/library-0.1.0.jar /Users/mreeve27/rustc_codegen_jvm/library/build/distributions/library-0.1.0/lib/kotlin-stdlib-2.1.20.jar --asm-processor /Users/mreeve27/rustc_codegen_jvm/asm-processor/build/libs/asm-processor-1.0-SNAPSHOT-all.jar --known-good kotlin-stdlib"
+]
+
+# Throwing a JVM exception will unwind and give a stack trace, no need for rust to handle unwinding.
+[profile.debug]
+panic = "abort"
+
+[profile.release]
+panic = "abort"

tests/binary/enums/Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "enums"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

tests/binary/enums/Cargo.toml

@@ -0,0 +1,15 @@
+enum Test {
+    A,
+    B,
+    C,
+}
+
+fn main() {
+    let mut test_enum = Test::A;
+
+    match test_enum {
+        Test::A => { /* correct */},
+        Test::B => panic!("Enum should be A, not B"),
+        Test::C => panic!("Enum shuld be A, not C"),
+    }
+}