Full enum support for Rust-like enums with anonymous structs or tuples and enums that are promoted constants.

Author: IntegralPilot

Readme.md

@@ -28,7 +28,7 @@ The toolchain transforms Rust code into executable `.jar` files through several
 This backend currently supports a subset of Rust features:
 
 *   ✅ Compiling minimal `no_std` & `no_core` Rust programs (like an empty `main`) using the `jvm-unknown-unknown` target.
-*   ✅ Compiling simple programs using basic `core` features (like the `is_even_plus_one` test) using the host target.
+*   ✅ Compiling simple programs using basic `core` features (like other tests) using the host target but this codegen backend to produce JVM bytecode.
 *   ✅ Basic integer arithmetic operations on all types of numbers:
     *   Addition (`+`), Subtraction (`-`), Multiplication (`*`), Division (`/`), Remainder (`%`).
     *   Checked addition, subtraction and multiplication returning `(result, overflowed_bool)` tuples (occurs in debug mode)
@@ -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, Tuples and Enums (currently only C-like enums, no anonymous structs or tuples yet) including nesting access/setting/mutation of fields.
+*   ✅ Structs, Tuples and Enums (including traditional C-like enums but also Rust-like enums with anonymous structs and tuples in them) including nested access/setting/mutation of fields and array indices within these.
 *   ✅ Generating executable `.jar` files for binary crates.
 
 ### Next Milestone:

library/src/main/kotlin/org/rustlang/core/Core.kt

@@ -1,5 +1,8 @@
 package org.rustlang.core
 
+import java.lang.reflect.Field
+import java.util.Objects
+
 /**
  * Core functions needed by the Rust JVM backend stdlib shim.
  */
@@ -65,21 +68,108 @@ public object Core {
 
     @JvmStatic
     public fun eq(value1: Any?, value2: Any?): Boolean {
-        // Check for equality.
-        return value1 == value2
+        // 1. Identity and Null checks
+        if (value1 === value2) { // Same reference or both null
+            return true
+        }
+        if (value1 == null || value2 == null) { // One is null, the other isn't
+            return false
+        }
+
+        // 2. Handle common Kotlin/Java types where '==' gives value equality
+        //    or specific content checks are needed.
+        val class1 = value1::class.java
+        val class2 = value2::class.java
+
+        if (class1 != class2) {
+             // Optimization: If classes are different, they generally can't be equal
+             // unless dealing with complex inheritance/interface scenarios not typical here.
+             // We might miss edge cases like comparing an Int to a Long with the same value,
+             // but Rust's PartialEq usually requires the types to be the same anyway.
+             return false
+        }
+
+        // Primitives/Wrappers and String -> rely on Kotlin's == (which calls .equals)
+        if (value1 is Number || value1 is String || value1 is Boolean || value1 is Char) {
+            return value1 == value2 // Uses overridden equals for these types
+        }
+
+        // Array Types -> use contentEquals
+        if (class1.isArray) {
+            return when (value1) {
+                is BooleanArray -> value1.contentEquals(value2 as BooleanArray)
+                is ByteArray -> value1.contentEquals(value2 as ByteArray)
+                is CharArray -> value1.contentEquals(value2 as CharArray)
+                is ShortArray -> value1.contentEquals(value2 as ShortArray)
+                is IntArray -> value1.contentEquals(value2 as IntArray)
+                is LongArray -> value1.contentEquals(value2 as LongArray)
+                is FloatArray -> value1.contentEquals(value2 as FloatArray)
+                is DoubleArray -> value1.contentEquals(value2 as DoubleArray)
+                is Array<*> -> value1.contentEquals(value2 as Array<*>) // For object arrays
+                else -> false // Should not happen if class1.isArray is true
+            }
+        }
+
+        // 3. Custom Generated Types (Heuristic: Not standard Java/Kotlin & same class)
+        // This assumes generated classes are not in standard packages.
+        val packageName = class1.packageName ?: ""
+        if (!packageName.startsWith("java.") && !packageName.startsWith("kotlin.")) {
+            try {
+                // Get all declared fields (including private) from the class definition
+                val fields: Array<Field> = class1.declaredFields
+
+                for (field in fields) {
+                     // Allow accessing private fields for comparison
+                    field.isAccessible = true
+
+                    // Recursively compare the field values
+                    val fieldValue1 = field.get(value1)
+                    val fieldValue2 = field.get(value2)
+
+                    // Recursive Call
+                    if (!eq(fieldValue1, fieldValue2)) {
+                        // If any field is not equal, the objects are not equal
+                        return false
+                    }
+                }
+                // If all fields were equal, the objects are equal
+                return true
+            } catch (e: Exception) {
+                // Log the exception if needed (e.g., IllegalAccessException)
+                System.err.println("Reflection error during eq: ${e.message}")
+                // Fallback: If reflection fails, assume not equal for safety
+                return false
+            }
+        }
+
+        // 4. Fallback: If none of the above, assume not equal.
+        return false
     }
 
     @JvmStatic
-    public fun core_panicking_panic(message: String?) {
+    public fun core_panic(message: String?) {
         // This is a placeholder for the panic function.
         // In a real implementation, this would handle the panic appropriately.
         throw RuntimeException("Rust panic: " + (message ?: "<no message>"))
     }
 
     @JvmStatic
-    public fun core_panicking_assert_failed(message: String?) {
+    public fun core_assert_failed(message: String?) {
         // This is a placeholder for the assert failed function.
         // In a real implementation, this would handle the assertion failure appropriately.
         throw AssertionError("Rust assertion failed: " + (message ?: "<no message>"))
     }
+
+    @JvmStatic
+    public fun deref(value: Any?): Any? {
+        // This is a placeholder for dereferencing.
+        return value
+    }
+
+    @JvmStatic 
+    fun core_starts_with(value: Any, prefixChar: Int): Boolean {
+        // Convert int to char/String and call original or implement directly
+        return value.toString().startsWith(Char(prefixChar).toString())
+    }
+
 }

shim-metadata-gen/core.json

@@ -7,6 +7,10 @@
     "descriptor": "([Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
     "is_static": true
   },
+  "core_assert_failed": {
+    "descriptor": "(Ljava/lang/String;)V",
+    "is_static": true
+  },
   "core_fmt_rt_argument_new_display": {
     "descriptor": "(Ljava/lang/Object;)Ljava/lang/String;",
     "is_static": true
@@ -23,12 +27,16 @@
     "descriptor": "(I)Ljava/lang/String;",
     "is_static": true
   },
-  "core_panicking_assert_failed": {
+  "core_panic": {
     "descriptor": "(Ljava/lang/String;)V",
     "is_static": true
   },
-  "core_panicking_panic": {
-    "descriptor": "(Ljava/lang/String;)V",
+  "core_starts_with": {
+    "descriptor": "(Ljava/lang/Object;I)Z",
+    "is_static": true
+  },
+  "deref": {
+    "descriptor": "(Ljava/lang/Object;)Ljava/lang/Object;",
     "is_static": true
   },
   "eq": {

src/lower1/control_flow.rs

@@ -102,6 +102,7 @@ pub fn convert_basic_block<'tcx>(
                         tcx,
                         mir,
                         data_types,
+                        &mut instructions,
                     );
                     instructions.push(oomir::Instruction::Return {
                         operand: Some(return_operand),
@@ -116,7 +117,7 @@ pub fn convert_basic_block<'tcx>(
             }
             TerminatorKind::SwitchInt { discr, targets, .. } => {
                 // --- GENERAL SwitchInt Handling ---
-                let discr_operand = convert_operand(discr, tcx, mir, data_types);
+                let discr_operand = convert_operand(discr, tcx, mir, data_types, &mut instructions);
                 // Get the actual type of the discriminant from MIR local declarations
                 let discr_ty = discr.ty(&mir.local_decls, tcx);
 
@@ -159,7 +160,7 @@ pub fn convert_basic_block<'tcx>(
                 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))
+                    .map(|arg| convert_operand(&arg.node, tcx, mir, data_types, &mut instructions))
                     .collect();
                 let dest = Some(format!("{:?}", destination.local));
 
@@ -219,7 +220,8 @@ pub fn convert_basic_block<'tcx>(
                         cond
                     );
                     // Condition is likely a constant itself
-                    condition_operand = convert_operand(cond, tcx, mir, data_types);
+                    condition_operand =
+                        convert_operand(cond, tcx, mir, data_types, &mut instructions);
                 }
                 // --- End of condition operand handling ---
 

src/lower1/control_flow/rvalue.rs

@@ -59,7 +59,8 @@ pub fn convert_rvalue_to_operand<'a>(
                 }
                 MirOperand::Constant(_) => {
                     // Constant is already an operand, no extra instructions
-                    result_operand = convert_operand(mir_operand, tcx, mir, data_types);
+                    result_operand =
+                        convert_operand(mir_operand, tcx, mir, data_types, &mut instructions);
                 }
             }
         }
@@ -71,7 +72,8 @@ pub fn convert_rvalue_to_operand<'a>(
 
             if let rustc_middle::ty::TyKind::Array(elem_ty, _) = place_ty.kind() {
                 let oomir_elem_type = ty_to_oomir_type(elem_ty.clone(), tcx, data_types);
-                let oomir_elem_op = convert_operand(element_op, tcx, mir, data_types);
+                let oomir_elem_op =
+                    convert_operand(element_op, tcx, mir, data_types, &mut instructions);
                 let array_size = match len_const.kind() {
                     ConstKind::Value(val) => {
                         /* ... extract size ... */
@@ -80,6 +82,7 @@ pub fn convert_rvalue_to_operand<'a>(
                             tcx.valtree_to_const_val(val),
                             &val.ty(),
                             tcx,
+                            data_types,
                         ))
                         .unwrap_or(0)
                     } // Simplified extraction
@@ -145,7 +148,7 @@ pub fn convert_rvalue_to_operand<'a>(
             let oomir_target_type = ty_to_oomir_type(*target_mir_ty, tcx, data_types);
             let source_mir_ty = operand.ty(&mir.local_decls, tcx);
             let oomir_source_type = ty_to_oomir_type(source_mir_ty, tcx, data_types);
-            let oomir_operand = convert_operand(operand, tcx, mir, data_types);
+            let oomir_operand = convert_operand(operand, tcx, mir, data_types, &mut instructions);
 
             if oomir_target_type == oomir_source_type {
                 println!("Info: Handling Rvalue::Cast (Same OOMIR Types) -> Temp Move.");
@@ -169,8 +172,8 @@ pub fn convert_rvalue_to_operand<'a>(
 
         Rvalue::BinaryOp(bin_op, box (op1, op2)) => {
             let temp_binop_var = generate_temp_var_name(&base_temp_name);
-            let oomir_op1 = convert_operand(op1, tcx, mir, data_types);
-            let oomir_op2 = convert_operand(op2, tcx, mir, data_types);
+            let oomir_op1 = convert_operand(op1, tcx, mir, data_types, &mut instructions);
+            let oomir_op2 = convert_operand(op2, tcx, mir, data_types, &mut instructions);
             // Determine result type based on operands or destination hint
             let oomir_result_type = get_place_type(original_dest_place, mir, tcx, data_types);
 
@@ -349,7 +352,8 @@ pub fn convert_rvalue_to_operand<'a>(
 
         Rvalue::UnaryOp(operation, operand) => {
             let temp_unop_var = generate_temp_var_name(&base_temp_name);
-            let oomir_src_operand = convert_operand(operand, tcx, mir, data_types);
+            let oomir_src_operand =
+                convert_operand(operand, tcx, mir, data_types, &mut instructions);
             // Determine result type (often same as operand, except for PtrMetadata)
             let oomir_result_type = match operation {
                 UnOp::PtrMetadata => oomir::Type::I32,
@@ -474,7 +478,8 @@ pub fn convert_rvalue_to_operand<'a>(
                         };
                         let element_oomir_type =
                             ty_to_oomir_type(element_mir_ty.clone(), tcx, data_types);
-                        let value_operand = convert_operand(mir_op, tcx, mir, data_types);
+                        let value_operand =
+                            convert_operand(mir_op, tcx, mir, data_types, &mut instructions);
                         instructions.push(oomir::Instruction::SetField {
                             object_var: temp_aggregate_var.clone(),
                             field_name,
@@ -500,7 +505,8 @@ pub fn convert_rvalue_to_operand<'a>(
                     });
                     // Store elements into the temporary array
                     for (i, mir_operand) in operands.iter().enumerate() {
-                        let value_operand = convert_operand(mir_operand, tcx, mir, data_types);
+                        let value_operand =
+                            convert_operand(mir_operand, tcx, mir, data_types, &mut instructions);
                         let index_operand =
                             oomir::Operand::Constant(oomir::Constant::I32(i as i32));
                         instructions.push(oomir::Instruction::ArrayStore {
@@ -530,7 +536,13 @@ pub fn convert_rvalue_to_operand<'a>(
                             let field_name = field_def.ident(tcx).to_string();
                             let field_mir_ty = field_def.ty(tcx, substs);
                             let field_oomir_type = ty_to_oomir_type(field_mir_ty, tcx, data_types);
-                            let value_operand = convert_operand(mir_operand, tcx, mir, data_types);
+                            let value_operand = convert_operand(
+                                mir_operand,
+                                tcx,
+                                mir,
+                                data_types,
+                                &mut instructions,
+                            );
                             instructions.push(oomir::Instruction::SetField {
                                 object_var: temp_aggregate_var.clone(),
                                 field_name,
@@ -671,6 +683,7 @@ pub fn convert_rvalue_to_operand<'a>(
                                 tcx,
                                 mir,
                                 data_types,
+                                &mut instructions,
                             );
                             instructions.push(oomir::Instruction::SetField {
                                 object_var: temp_aggregate_var.clone(),