Support for traits (+ new unit test verifying this!) :)

Author: IntegralPilot

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2024"
 bigdecimal = "0.4.8"
 half = "2.6.0"
 libc = "0.2.172"
+md5 = "0.7.0"
 num-bigint = "0.4.6"
 num-traits = "0.2.19"
 regex = "1.11.1"

Cargo.toml

@@ -32,7 +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)**
+* **[Implementation blocks](tests/binary/impl/src/main.rs)** and **[traits](tests/binary/traits/src/main.rs)**
 - …and more!
 
 ---
@@ -52,6 +52,7 @@ All examples live in `tests/binary` and are compiled to JVM bytecode & run/teste
 - Executable `.jar` generation for binary crates  
 - Mutable borrowing, references, and dereferencing
 - Implementations for ADTs, including using and returning `self`, `&self`, `&mut self`
+- Traits!
 - **Integration tests** for all features, in debug and release modes
 
 🚧 **Next Milestone:** Full support for the Rust `core` crate.

Readme.md

@@ -45,8 +45,6 @@ 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...")

Tester.py

@@ -77,7 +77,7 @@ public object Core {
     }
 
     @JvmStatic
-    public fun arguments_new_const(pieces: Array<String>): String {
+    public fun arguments_new_const_1(pieces: Array<String>): String {
         // Concatenate all the string pieces together.
         // This mimics the simplest formatting scenario where pieces are just joined.
         // If the array is empty, it correctly returns an empty string.
@@ -219,10 +219,82 @@ public object Core {
         return false
     }
 
+
+    // variants of eq that just call the main one. need A LOT of these since we are now properly resolving generics
+    // will no longer be needed once we compile the real `core` library which will generate all of these - support is almost there
+    // placeholders just for now
+
+    @JvmStatic
+    public fun str_eq(value1: String?, value2: String?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun f16_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun f32_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    // (f32, f32) tuple
+    public fun f32_f32_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun f64_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun f128_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun i64_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    // tuple (i32, i32, i32)
+    public fun i32_i32_i32_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+    
     @JvmStatic
-    public fun core_panic(message: String?) {
-        // This is a placeholder for the panic function.
-        // In a real implementation, this would handle the panic appropriately.
+    // tuple (i32, u8, bool)
+    public fun i32_u8_bool_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    // [u8; 8]
+    public fun u8_8_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun raw_eq_u8_8(slice1: Any?, slice2: Any?): Boolean {
+        return eq(slice1, slice2)
+    }
+
+    @JvmStatic
+    public fun u8_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+    
+    @JvmStatic
+    public fun option_usize_eq(value1: Any?, value2: Any?): Boolean {
+        return eq(value1, value2)
+    }
+
+    @JvmStatic
+    public fun core_panicking_panic(message: String?) {
         throw RuntimeException("Rust panic: " + (message ?: "<no message>"))
     }
 
@@ -240,7 +312,7 @@ public object Core {
     }
 
 @JvmStatic
-fun core_starts_with(value: Any, prefix: Any): Boolean {
+fun core_str_str_starts_with_char(value: Any, prefix: Any): Boolean {
     // Runtime type check needed here!
     return when {
         value is String && prefix is String -> { // Both are strings
@@ -270,6 +342,12 @@ fun core_starts_with(value: Any, prefix: Any): Boolean {
         }
     }
 }
+
+// wrapper that just calls the above
+@JvmStatic
+public fun core_slice_u8_starts_with(value: Any, prefix: Any): Boolean {
+    return core_str_str_starts_with_char(value, prefix)
+}
     @JvmStatic
     public fun option_unwrap(optionObj: Any?): Any? {
         if (optionObj == null) {
@@ -332,7 +410,13 @@ fun core_starts_with(value: Any, prefix: Any): Boolean {
         }
     }
 
-        /**
+    // redirectors for monomorphised versions of the above, to just call the above
+    @JvmStatic
+    public fun option_usize_is_none(optionObj: Any?): Boolean {
+        return option_is_none(optionObj)
+    }
+
+    /**
      * Shim for `<[T] as SlicePartialEq<T>>::equal`.
      * Handles comparison of primitive arrays based on OOMIR types.
      * Primarily expects ByteArray (for u8) or ShortArray (due to I16 OOMIR type from String casts).
@@ -362,6 +446,14 @@ fun core_starts_with(value: Any, prefix: Any): Boolean {
         }
     }
 
+    // monomorphised versions of the above
+    @JvmStatic
+    // a slice of u8
+    public fun u8_equal(slice1: Any?, slice2: Any?): Boolean {
+        return equal(slice1, slice2)
+    }
+ 
+
     /**
      * Convert a Java String into a ShortArray, by casting each char to a short.
      */

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

@@ -1,5 +1,5 @@
 {
-  "arguments_new_const": {
+  "arguments_new_const_1": {
     "descriptor": "([Ljava/lang/String;)Ljava/lang/String;",
     "is_static": true
   },
@@ -27,11 +27,15 @@
     "descriptor": "(I)Ljava/lang/String;",
     "is_static": true
   },
-  "core_panic": {
+  "core_panicking_panic": {
     "descriptor": "(Ljava/lang/String;)V",
     "is_static": true
   },
-  "core_starts_with": {
+  "core_slice_u8_starts_with": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "core_str_str_starts_with_char": {
     "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
     "is_static": true
   },
@@ -51,10 +55,42 @@
     "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
     "is_static": true
   },
+  "f128_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "f16_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "f32_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "f32_f32_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "f64_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
   "fromShortArray": {
     "descriptor": "([S)Ljava/lang/String;",
     "is_static": true
   },
+  "i32_i32_i32_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "i32_u8_bool_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "i64_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
   "option_is_none": {
     "descriptor": "(Ljava/lang/Object;)Z",
     "is_static": true
@@ -63,16 +99,44 @@
     "descriptor": "(Ljava/lang/Object;)Ljava/lang/Object;",
     "is_static": true
   },
+  "option_usize_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "option_usize_is_none": {
+    "descriptor": "(Ljava/lang/Object;)Z",
+    "is_static": true
+  },
   "panic_fmt": {
     "descriptor": "(Ljava/lang/Object;)V",
     "is_static": true
   },
+  "raw_eq_u8_8": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "str_eq": {
+    "descriptor": "(Ljava/lang/String;Ljava/lang/String;)Z",
+    "is_static": true
+  },
   "toShortArray": {
     "descriptor": "(Ljava/lang/String;)[S",
     "is_static": true
   },
   "to_string": {
     "descriptor": "(Ljava/lang/Object;)Ljava/lang/String;",
     "is_static": true
+  },
+  "u8_8_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "u8_eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
+  "u8_equal": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
   }
 }

shim-metadata-gen/core.json

@@ -77,10 +77,6 @@ impl CodegenBackend for MyBackend {
             } = item.kind
             {
                 let def_id = item_id.owner_id.to_def_id();
-                if tcx.generics_of(def_id).count() != 0 {
-                    println!("Skipping generic function: {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
 
@@ -122,10 +118,6 @@ impl CodegenBackend for MyBackend {
                     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
 

src/lib.rs

@@ -905,6 +905,16 @@ pub fn convert_rvalue_to_operand<'a>(
                 ty: method_return_type, // Should be I32
             };
         }
+        Rvalue::CopyForDeref(place) => {
+            // Need to get the value from the source place first
+            let (temp_var_name, get_instructions, temp_var_type) =
+            emit_instructions_to_get_on_own(place, tcx, mir, data_types);
+            instructions.extend(get_instructions);
+            result_operand = oomir::Operand::Variable {
+                name: temp_var_name,
+                ty: temp_var_type,
+            };        
+        }
         // Handle other Rvalue variants by generating a placeholder
         _ => {
             println!(