Support both user-defined and standard library structs and tuples. Tests added to ensure this works.

Author: IntegralPilot

Cargo.lock

@@ -8,6 +8,7 @@ regex = "1.11.1"
 ristretto_classfile = { version = "0.16.0" }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
+sha2 = "0.10.8"
 
 [lib]
 crate-type = ["dylib"]

Cargo.toml

@@ -39,6 +39,7 @@ This backend currently supports a subset of Rust features:
 *   ✅ Basic variable assignment (`let x = y;`).
 *   ✅ Arrays and slices.
 *   ✅ Floats (`f32`, `f64`).
+*   ✅ Structs and Tuples (enums and unions coming soon!)
 *   ✅ Generating executable `.jar` files for binary crates.
 
 ### Next Milestone:

Readme.md

@@ -357,7 +357,7 @@ fn create_jar(
     zip_writer.start_file("META-INF/MANIFEST.MF", options)?;
     zip_writer.write_all(manifest_content.as_bytes())?;
 
-    let re = Regex::new(r"^(.*?)-[0-9a-fA-F]+(\.class)$").unwrap();
+    let re = Regex::new(r"^[^-]+-[0-9a-fA-F]+\.(?P<name>[^/\\]+\.class)$").unwrap();
     let mut added_class_files = std::collections::HashSet::new();
 
     for input_file_path_str in input_files {
@@ -439,16 +439,11 @@ fn create_jar(
                 })?;
 
             let jar_entry_name = if let Some(caps) = re.captures(original_file_name) {
-                format!("{}{}", &caps[1], &caps[2])
+                caps["name"].to_string()
             } else {
-                // If not hashed, assume the filename corresponds to the path within the JAR.
-                // This might need adjustment depending on how class files are laid out relative
-                // to their package structure on the filesystem before being passed to the linker.
-                // For now, we just use the filename. A better approach might involve stripping
-                // a known source root path.
                 original_file_name.to_string()
             };
-
+                
             if !added_class_files.contains(&jar_entry_name) {
                 let is_known_good = known_good_identifier
                     .map(|id| input_file_path_str.contains(id))

java-linker/src/main.rs

@@ -56,4 +56,16 @@ public object Core {
         }
         return sb.toString()
     }
+
+    @JvmStatic 
+    public fun to_string(value: Any?): String {
+        // Convert the value to a string.
+        return value?.toString() ?: "null"
+    }
+
+    @JvmStatic
+    public fun eq(value1: Any?, value2: Any?): Boolean {
+        // Check for equality.
+        return value1 == value2
+    }
 }

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

@@ -23,8 +23,16 @@
     "descriptor": "(I)Ljava/lang/String;",
     "is_static": true
   },
+  "eq": {
+    "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+    "is_static": true
+  },
   "panic_fmt": {
     "descriptor": "(Ljava/lang/String;)V",
     "is_static": true
+  },
+  "to_string": {
+    "descriptor": "(Ljava/lang/Object;)Ljava/lang/String;",
+    "is_static": true
   }
 }

shim-metadata-gen/core.json

@@ -30,7 +30,7 @@ use rustc_metadata::EncodedMetadata;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::{Session, config::OutputFilenames};
-use std::{any::Any, io::Write, path::Path, vec};
+use std::{any::Any, io::Write, path::Path};
 
 mod lower1;
 mod lower2;
@@ -57,6 +57,7 @@ impl CodegenBackend for MyBackend {
         let mut oomir_module = oomir::Module {
             name: crate_name.clone(),
             functions: std::collections::HashMap::new(),
+            data_types: std::collections::HashMap::new(),
         };
 
         // Iterate through all items in the crate and find functions
@@ -82,12 +83,16 @@ impl CodegenBackend for MyBackend {
                 println!("MIR for function {i}: {:?}", mir);
 
                 println!("--- Starting MIR to OOMIR Lowering for function: {i} ---");
-                let oomir_function = lower1::mir_to_oomir(tcx, instance, &mut mir);
+                let oomir_result = lower1::mir_to_oomir(tcx, instance, &mut mir);
                 println!("--- Finished MIR to OOMIR Lowering for function: {i} ---");
 
+                let oomir_function = oomir_result.0;
+
                 oomir_module
                     .functions
                     .insert(oomir_function.name.clone(), oomir_function);
+
+                oomir_module.merge_data_types(&oomir_result.1);
             }
         }
 
@@ -119,30 +124,46 @@ impl CodegenBackend for MyBackend {
         outputs: &OutputFilenames,
     ) -> (CodegenResults, FxIndexMap<WorkProductId, WorkProduct>) {
         std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-            let (bytecode, crate_name, metadata, crate_info) = *ongoing_codegen
-                .downcast::<(Vec<u8>, String, EncodedMetadata, CrateInfo)>()
-                .expect("in join_codegen: ongoing_codegen is not bytecode vector");
-
-            let class_path = outputs.temp_path_ext("class", None);
-
-            let mut class_file =
-                std::fs::File::create(&class_path).expect("Could not create the Java .class file!");
-            class_file
-                .write_all(&bytecode)
-                .expect("Could not write Java bytecode to file!");
-
-            let modules = vec![CompiledModule {
-                name: crate_name,
-                kind: ModuleKind::Regular,
-                object: Some(class_path),
-                bytecode: None,
-                dwarf_object: None,
-                llvm_ir: None,
-                links_from_incr_cache: Vec::new(),
-                assembly: None,
-            }];
+            // Update the downcast to expect a HashMap now.
+            let (bytecode_map, _, metadata, crate_info) = *ongoing_codegen
+                .downcast::<(
+                    std::collections::HashMap<String, Vec<u8>>,
+                    String,
+                    EncodedMetadata,
+                    CrateInfo,
+                )>()
+                .expect("in join_codegen: ongoing_codegen is not a bytecode map");
+    
+            let mut compiled_modules = Vec::new();
+    
+            // Iterate over each (file_name, bytecode) pair in the map.
+            for (name, bytecode) in bytecode_map.into_iter() {
+                // The key is expected to be the file name without the ".class" extension.
+                // Append ".class" here.
+                let file_name = format!("{}.class", name);
+                let file_path = outputs.temp_path_ext(&file_name, None);
+    
+                // Write the bytecode to the file
+                let mut file = std::fs::File::create(&file_path)
+                    .unwrap_or_else(|e| panic!("Could not create file {}: {}", file_path.display(), e));
+                file.write_all(&bytecode)
+                    .unwrap_or_else(|e| panic!("Could not write bytecode to file {}: {}", file_path.display(), e));
+    
+                // Create a CompiledModule for this file
+                compiled_modules.push(CompiledModule {
+                    name: name.clone(),
+                    kind: ModuleKind::Regular,
+                    object: Some(file_path),
+                    bytecode: None,
+                    dwarf_object: None,
+                    llvm_ir: None,
+                    links_from_incr_cache: Vec::new(),
+                    assembly: None,
+                });
+            }
+    
             let codegen_results = CodegenResults {
-                modules,
+                modules: compiled_modules,
                 allocator_module: None,
                 metadata_module: None,
                 metadata,
@@ -152,7 +173,7 @@ impl CodegenBackend for MyBackend {
         }))
         .expect("Could not join_codegen")
     }
-
+    
     fn link(&self, sess: &Session, codegen_results: CodegenResults, outputs: &OutputFilenames) {
         println!("linking!");
         use rustc_codegen_ssa::back::link::link_binary;