Refactor structs test to more also test nested mutation, and test structs, tuples and arrays/slicies not just structs.

Author: IntegralPilot

Readme.md

@@ -39,10 +39,11 @@ This backend currently supports a subset of Rust features:
 *   ✅ Type casting (e.g., `as` operator).
 *   ✅ Support for all primitive types.
 *   ✅ Calling other functions (including recursion).
+*   ✅ Loops such as `for`, `while`, and `loop`.
 *   ✅ Variable assignment including subfield and array index assignment, including nesting.
-*   ✅ Arrays and slices, including inserting, accessing and mutating at a given index.
+*   ✅ 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!)
+*   ✅ Structs and Tuples (enums and unions coming soon!) including nesting access/setting/mutation of fields.
 *   ✅ Generating executable `.jar` files for binary crates.
 
 ### Next Milestone:

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

@@ -75,4 +75,11 @@ public object Core {
         // 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?) {
+        // 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>"))
+    }
 }

shim-metadata-gen/core.json

@@ -23,6 +23,10 @@
     "descriptor": "(I)Ljava/lang/String;",
     "is_static": true
   },
+  "core_panicking_assert_failed": {
+    "descriptor": "(Ljava/lang/String;)V",
+    "is_static": true
+  },
   "core_panicking_panic": {
     "descriptor": "(Ljava/lang/String;)V",
     "is_static": true

src/lower1/control_flow/rvalue.rs

@@ -551,7 +551,11 @@ pub fn convert_rvalue_to_operand<'a>(
                     } else {
                         // Enum, Union
                         println!("Warning: Unhandled ADT Aggregate Kind -> Temp Placeholder");
-                        // No instructions needed for placeholder, result set below
+                        // make a placeholder (Class("java/lang/Object"))
+                        instructions.push(oomir::Instruction::ConstructObject {
+                            dest: temp_aggregate_var.clone(),
+                            class_name: "java/lang/Object".to_string(),
+                        });
                     }
                 }
                 _ => {

src/lower2/translator.rs

@@ -1364,6 +1364,7 @@ impl<'a, 'cp> FunctionTranslator<'a, 'cp> {
                             // Currently hardcoded
                             if function_name == "panic_fmt"
                                 || function_name == "core_panicking_panic"
+                                || function_name == "core_panicking_assert_failed"
                             {
                                 is_diverging_call = true;
                             }

tests/binary/structs/src/main.rs

@@ -1,52 +1,63 @@
-#[derive(Debug)]
-struct NestedStruct {
-    // A nested struct that holds an array.
-    values: [i32; 3],
+struct Inner {
+    x: i32,
+    y: (i32, i32),
 }
 
-#[derive(Debug)]
-struct TestStruct {
-    field1: i32,
-    field2: String,
-    // Nested struct inside the main struct.
-    nested: NestedStruct,
+struct Outer {
+    label: String,
+    inner_struct: Inner,
+    data: [i32; 3],
 }
 
 fn main() {
-    // Initialize the nested struct with an array.
-    let nested = NestedStruct { values: [10, 20, 30] };
-
-    // Initialize the main structure with two simple fields and one nested struct.
-    let test_struct = TestStruct {
-        field1: 180,
-        field2: "rust".to_string(),
-        nested,
+    // === Nested STRUCT + TUPLE + ARRAY ===
+    let mut outer = Outer {
+        label: "start".to_string(),
+        inner_struct: Inner {
+            x: 100,
+            y: (5, 10),
+        },
+        data: [1, 2, 3],
     };
 
-    // Test simple field accesses.
-    assert!(test_struct.field1 == 180, "Field1 should be 180");
-    assert!(test_struct.field2 == "rust", "Field2 should be 'rust'");
-
-    // Test nested field access (accessing a field from the nested struct).
-    assert!(test_struct.nested.values[0] == 10, "First element in nested.values should be 10");
-    assert!(test_struct.nested.values[1] == 20, "Second element in nested.values should be 20");
-    assert!(test_struct.nested.values[2] == 30, "Third element in nested.values should be 30");
-
-    // If you want to test even deeper nesting, for instance, an array containing nested structs:
-    let more_nested: [TestStruct; 2] = [
-        TestStruct {
-            field1: 100,
-            field2: "foo".to_string(),
-            nested: NestedStruct { values: [1, 2, 3] },
-        },
-        TestStruct {
-            field1: 200,
-            field2: "bar".to_string(),
-            nested: NestedStruct { values: [4, 5, 6] },
-        },
-    ];
+    // === Access nested values ===
+    assert!(outer.label == "start");
+    assert!(outer.inner_struct.x == 100, "Inner x should be 100");
+    assert!(outer.inner_struct.y.0 == 5, "Inner tuple y.0 should be 5");
+    assert!(outer.inner_struct.y.1 == 10, "Inner tuple y.1 should be 10");
+    assert!(outer.data[0] == 1, "Array element at index 0 should be 1");
+
+    // === Mutate nested values ===
+   outer.label = "updated".to_string();
+    outer.inner_struct.x = 200;
+    outer.inner_struct.y.1 = 999;
+    outer.data[1] = 42;
+
+    // === Assert mutations ===
+    assert!(outer.label == "updated", "Outer label should be updated");
+    assert!(outer.inner_struct.x == 200, "Inner x should now be 200");
+    assert!(outer.inner_struct.y.1 == 999, "Inner tuple y.1 should now be 999");
+    assert!(outer.data[1] == 42, "Array element at index 1 should now be 42");
+
+    // === Tuple nesting test ===
+    let mut big_tuple = (
+        (10, 20),
+        Inner { x: 50, y: (7, 8) },
+        ["a", "b", "c"],
+    );
+
+    // Access nested tuple values
+    assert!((big_tuple.0).1 == 20, "First tuple's second element should be 20");
+    assert!(big_tuple.1.y.0 == 7, "Nested tuple inside struct should be 7");
+    assert!(big_tuple.2[2] == "c", "Array inside tuple should contain 'c' at index 2");
+
+    // Mutate nested values
+    (big_tuple.0).0 = 99;
+    big_tuple.1.x = 123;
+    big_tuple.2[1] = "z";
 
-    // Test access into the array and then the nested struct.
-    assert!(more_nested[0].field1 == 100, "First element's field1 should be 100");
-    assert!(more_nested[1].nested.values[2] == 6, "Second element's nested.values[2] should be 6");
+    // Assert changes
+    assert!((big_tuple.0).0 == 99, "Tuple value mutated to 99");
+    assert!(big_tuple.1.x == 123, "Inner struct field x mutated to 123");
+    assert!(big_tuple.2[1] == "z", "Tuple's array element at index 1 mutated to 'z'");
 }