Add support for providing more than 1 argument to format!, arrays, and floats.

- Introduced new formatting functions in Core.kt for displaying integers, booleans, doubles, and general objects.
- Implemented `arguments_new_v1` to format strings with arguments, rather than just a simple string.
- Enhanced lower1.rs to map specific Rust types to JVM types, including handling for `core::fmt::Arguments` and arrays.
- Improved handling of scalar types in lower1.rs, including float types.
- Updated lower2.rs to manage local variable types and ensure type consistency during assignments.
- Added support for array creation and storage in lower2.rs.
- Introduced new tests for panic scenarios, ensuring proper formatting and output.
- Introduced proper linking to Kotlin's stdlib, and ensured these files can be excluded from asm-processor.

Author: IntegralPilot

Makefile

@@ -46,7 +46,8 @@ clean-java-linker:
 	cd java-linker && cargo clean
 
 # === Library shim metadata generator ===
-shim-metadata-gen: library
+# needs to clean first so unzip doesn't prompt for overwrite
+shim-metadata-gen: clean-library library
 	@echo "$(CYAN)🔧 Generating shim metadata...$(RESET)"
 	cd shim-metadata-gen && rm -f core.json && cargo run -- ../library/build/libs/library-0.1.0.jar ./core.json
 
@@ -66,7 +67,7 @@ clean-asm-processor:
 # === Standard Library Shim (Gradle) ===
 library:
 	@echo "$(CYAN)📚 Building standard library shim...$(RESET)"
-	cd library && gradle build
+	cd library && gradle build && cd build/distributions && unzip library-0.1.0.zip
 
 clean-library:
 	@echo "$(CYAN)🧹 Cleaning library shim...$(RESET)"

Readme.md

@@ -84,8 +84,15 @@ To compile *your own* Rust project using this backend:
         rustflags = [
           "-Z", "codegen-backend=/path/to/rustc_codegen_jvm/target/debug/librustc_codegen_jvm.dylib",
           "-C", "linker=/path/to/rustc_codegen_jvm/java-linker/target/debug/java-linker",
-          "-C", "link-args=--asm-processor /path/to/rustc_codegen_jvm/asm-processor/build/libs/asm-processor-1.0-SNAPSHOT-all.jar"
+          "-C", "link-args=/path/to/rustc_codegen_jvm/library/build/distributions/library-0.1.0/lib/library-0.1.0.jar /path/to/rustc_codegen_jvm/library/build/distributions/library-0.1.0/lib/kotlin-stdlib-2.1.20.jar --asm-processor /path/to/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"
         ```
     *   **Important:** Replace `/path/to/rustc_codegen_jvm/...` with the path to where you cloned the repository. If you're not on macOS, changed `.dylib` to `.so` for Linux or `.dll` for Windows.
 
@@ -111,7 +118,7 @@ To compile *your own* Rust project using this backend:
 This project includes integration tests managed by a Python script.
 
 1.  **Ensure Toolchain is Built:** Build the project using `make all`.
-2.  **Check Target JSON:** Make sure the `jvm-unknown-unknown.json` file in the *root* of this repository has the **relative paths** starting with `../../../` for the linker and backend, as the tester expects this structure when running tests from subdirectories. If you changed them to absolute paths for external use, change them back temporarily.
+2.  **Check Target JSON:** Make sure the `jvm-unknown-unknown.json` file in the *root* of this repository has the **relative paths** starting with `/path/to/rustc_codegen_jvm/` for the linker and backend, as the tester expects this structure when running tests from subdirectories. If you changed them to absolute paths for external use, change them back temporarily.
 3.  **Run the Tester:**
     ```bash
     python3 Tester.py

Tester.py

@@ -39,9 +39,7 @@ def process_test(test_dir: str, release_mode: bool):
     print("|--- ⚒️ Building with Cargo...")
     build_cmd = ["cargo", "build", "--release"] if release_mode else ["cargo", "build"]
     no_jvm_target = os.path.join(test_dir, "no_jvm_target.flag")
-    if os.path.exists(no_jvm_target):
-        print("|---- ⚠️ Skipping JVM target build due to no_jvm_target.flag")
-    else:
+    if not os.path.exists(no_jvm_target):
         print("|---- 🛠️ Building with JVM target...")
         build_cmd.extend(["--target", "../../../jvm-unknown-unknown.json"])
     proc = run_command(build_cmd, cwd=test_dir)
@@ -56,7 +54,6 @@ def process_test(test_dir: str, release_mode: bool):
     print("|--- 🤖 Running with Java...")
     target_dir = "release" if release_mode else "debug"
     if os.path.exists(no_jvm_target):
-        print("|---- ⚠️ Doing some needed moving around due to no_jvm_target.flag")
         jar_path = os.path.join(test_dir, "target", target_dir, "deps", f"{test_name}-*.jar")
         jar_file = None
         for file in os.listdir(os.path.join(test_dir, "target", target_dir, "deps")):
@@ -70,22 +67,40 @@ def process_test(test_dir: str, release_mode: bool):
         os.rename(os.path.join(test_dir, "target", target_dir, "deps", jar_file), os.path.join(test_dir, "target", "jvm-unknown-unknown", target_dir, f"{test_name}.jar"))
     jar_path = os.path.join(test_dir, "target", "jvm-unknown-unknown", target_dir, f"{test_name}.jar")
     proc = run_command(["java", "-jar", jar_path]) 
-    if proc.returncode != 0:
-        fail_path = os.path.join(test_dir, "java-fail.generated")
-        output = f"STDOUT:\n{proc.stdout}\n\nSTDERR:\n{proc.stderr}"
-        write_to_file(fail_path, output)
-        print(f"|---- ❌ java exited with code {proc.returncode}")
-        return False
+    
+    # Check for java-returncode.expected
+    expected_returncode_file = os.path.join(test_dir, "java-returncode.expected")
+    if os.path.exists(expected_returncode_file):
+        expected_returncode = int(read_from_file(expected_returncode_file).strip())
+        if proc.returncode != expected_returncode:
+            fail_path = os.path.join(test_dir, "java-returncode-fail.generated")
+            output = f"Expected return code: {expected_returncode}\nActual return code: {proc.returncode}\n\nSTDOUT:\n{proc.stdout}\n\nSTDERR:\n{proc.stderr}"
+            write_to_file(fail_path, output)
+            print(f"|---- ❌ java exited with code {proc.returncode}, expected {expected_returncode}")
+            return False
+    else:
+        if proc.returncode != 0:
+            fail_path = os.path.join(test_dir, "java-fail.generated")
+            output = f"STDOUT:\n{proc.stdout}\n\nSTDERR:\n{proc.stderr}"
+            write_to_file(fail_path, output)
+            print(f"|---- ❌ java exited with code {proc.returncode}")
+            return False
 
-    # Compare the STDOUT to {test_dir}/java_output.expected
-    expected_file = os.path.join(test_dir, "java_output.expected")
+    # Compare the STDOUT and STDERR to {test_dir}/java-output.expected
+    expected_file = os.path.join(test_dir, "java-output.expected")
     if os.path.exists(expected_file):
         expected_output = read_from_file(expected_file)
-        actual_output = proc.stdout.strip()
+        # special case: blank file = no STDOUT or STDERR expected
+        if expected_output.strip() == "":
+            expected_output = "STDOUT:STDERR:"
+        else:
+            expected_output = expected_output.replace("\n", "")
+        actual_output = f"STDOUT:{proc.stdout.strip()}STDERR:{proc.stderr.strip()}"
+        # remove all remaining newlines
+        actual_output = actual_output.replace("\n", "")
         if actual_output != expected_output.strip():
             diff_path = os.path.join(test_dir, "output-diff.generated")
-            diff_output = f"Expected:\n{expected_output}\n\nGot:\n{actual_output}"
-            write_to_file(diff_path, diff_output)
+            write_to_file(diff_path, actual_output)
             print("|---- ❌ java output did not match expected output")
             return False
         else:

java-linker/src/main.rs

@@ -11,13 +11,14 @@ use tempfile::NamedTempFile;
 fn main() -> Result<(), i32> {
     let args: Vec<String> = env::args().collect();
     if args.len() < 3 {
-        eprintln!("Usage: java-linker <input_files...> -o <output_jar_file> [--asm-processor <processor_jar>]");
+        eprintln!("Usage: java-linker <input_files...> -o <output_jar_file> [--asm-processor <processor_jar>] [--known-good <identifier>]");
         return Err(1);
     }
 
     let mut input_files: Vec<String> = Vec::new();
     let mut output_file: Option<String> = None;
     let mut processor_jar_path: Option<PathBuf> = None;
+    let mut known_good_identifier: Option<String> = None;
 
     let mut i = 1;
     while i < args.len() {
@@ -38,11 +39,19 @@ fn main() -> Result<(), i32> {
                 eprintln!("Error: --asm-processor flag requires a path");
                 return Err(1);
             }
+        } else if arg == "--known-good" {
+            if i + 1 < args.len() {
+                known_good_identifier = Some(args[i + 1].clone());
+                i += 2;
+            } else {
+                eprintln!("Error: --known-good flag requires an identifier string");
+                return Err(1);
+            }
         } else if !arg.starts_with("-") && (arg.ends_with(".class") || arg.ends_with(".jar")) {
             input_files.push(arg.clone());
             i += 1;
         } else {
-            i += 1; // Ignore flags
+            i += 1;
         }
     }
 
@@ -51,7 +60,6 @@ fn main() -> Result<(), i32> {
         return Err(1);
     }
 
-    // if output_file doesn't end in .jar, add .jar
     if let Some(ref path) = output_file {
         if !path.ends_with(".jar") {
             eprintln!("Warning: Output file should end with .jar. Adding .jar extension.");
@@ -74,21 +82,18 @@ fn main() -> Result<(), i32> {
         return Err(1);
     }
 
-    // Prepare the regex for sanitizing the main class file name.
     let re = Regex::new(r"^(.*?)-[0-9a-f]+(\.class)$").unwrap();
     let main_class_name = main_classes.first().map(|class_path| {
         let file_name = Path::new(class_path)
             .file_name()
             .unwrap()
             .to_str()
             .unwrap();
-        // Sanitize the file name if it matches the pattern.
         let cleaned_name = if let Some(caps) = re.captures(file_name) {
             format!("{}{}", &caps[1], &caps[2])
         } else {
             file_name.to_string()
         };
-        // Remove the ".class" extension and replace "/" with "." to get the fully qualified name.
         cleaned_name.trim_end_matches(".class").replace("/", ".")
     });
 
@@ -100,7 +105,13 @@ fn main() -> Result<(), i32> {
         }
     }
 
-    if let Err(err) = create_jar(&input_files, &output_file_path, main_class_name.as_deref(), processor_jar_path) {
+    if let Err(err) = create_jar(
+        &input_files,
+        &output_file_path,
+        main_class_name.as_deref(),
+        processor_jar_path,
+        known_good_identifier.as_deref(),
+    ) {
         eprintln!("Error creating JAR: {}", err);
         return Err(1);
     }
@@ -115,7 +126,6 @@ fn find_main_classes(class_files: &[String]) -> Vec<String> {
     let main_descriptor = b"([Ljava/lang/String;)V";
 
     for file in class_files {
-        // Only check .class files for main method bytes
         if file.ends_with(".class") {
             if let Ok(data) = fs::read(file) {
                 let has_main_name = data.windows(main_name.len()).any(|w| w == main_name);
@@ -151,30 +161,38 @@ fn create_jar(
     output_jar_path: &str,
     main_class_name: Option<&str>,
     processor_jar_path: Option<&Path>,
+    known_good_identifier: Option<&str>,
 ) -> io::Result<()> {
     let output_file = fs::File::create(output_jar_path)?;
     let mut zip_writer = ZipWriter::new(output_file);
     let options = SimpleFileOptions::default()
         .compression_method(CompressionMethod::DEFLATE)
         .unix_permissions(0o644);
 
-    // Create META-INF/MANIFEST.MF
     let manifest_content = create_manifest_content(main_class_name);
     zip_writer.start_file("META-INF/MANIFEST.MF", options)?;
     zip_writer.write_all(manifest_content.as_bytes())?;
 
     let re = Regex::new(r"^(.*?)-[0-9a-f]+(\.class)$").unwrap();
-
-    // Track all class files we've added to avoid duplicates
     let mut added_class_files = std::collections::HashSet::new();
 
     for input_file_path_str in input_files {
         if input_file_path_str.ends_with(".jar") {
             println!("Processing JAR file: {}", input_file_path_str);
             let class_files = process_jar_file(input_file_path_str)?;
-            
+
             for (class_path, class_data) in class_files {
                 if !added_class_files.contains(&class_path) {
+                    if let Some(known_str) = known_good_identifier {
+                        if input_file_path_str.contains(known_str) {
+                            println!("Skipping ASM processing for known-good JAR file: {}", class_path);
+                            zip_writer.start_file(&class_path, options)?;
+                            zip_writer.write_all(&class_data)?;
+                            added_class_files.insert(class_path.clone());
+                            continue;
+                        }
+                    }
+
                     let processed_data = if let Some(processor_path) = processor_jar_path {
                         let temp_out_file = NamedTempFile::new()?;
                         let temp_in_file = NamedTempFile::new()?;
@@ -224,8 +242,18 @@ fn create_jar(
             };
 
             if !added_class_files.contains(&jar_entry_name) {
-                println!("Processing class file: {}", input_file_path_str);
+                if let Some(known_str) = known_good_identifier {
+                    if input_file_path_str.contains(known_str) {
+                        println!("Skipping ASM processing for known-good class: {}", input_file_path_str);
+                        let file_data = fs::read(input_file_path_str)?;
+                        zip_writer.start_file(&jar_entry_name, options)?;
+                        zip_writer.write_all(&file_data)?;
+                        added_class_files.insert(jar_entry_name);
+                        continue;
+                    }
+                }
 
+                println!("Processing class file: {}", input_file_path_str);
                 let file_data = if let Some(processor_path) = processor_jar_path {
                     let temp_out_file = NamedTempFile::new()?;
                     let temp_out_path = temp_out_file.path().to_path_buf();

library/build.gradle.kts

@@ -10,6 +10,10 @@ repositories {
     mavenCentral()
 }
 
+dependencies {
+    implementation(kotlin("stdlib"))
+}
+
 kotlin {
     jvmToolchain(21) // latest LTS. note to self: update when they release a new LTS.
 }

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

@@ -4,8 +4,7 @@ package org.rustlang.core
  * Core functions needed by the Rust JVM backend stdlib shim.
  */
 public object Core {
-
-    @JvmStatic // Ensures static JVM methods are generated
+    @JvmStatic
     public fun panic_fmt(message: String?) {
         // note to future self: consider using a more specific Rust exception type if needed
         throw RuntimeException("Rust panic: " + (message ?: "<no message>"))
@@ -18,4 +17,43 @@ public object Core {
         // If the array is empty, it correctly returns an empty string.
         return pieces.joinToString("")
     }
+
+    @JvmStatic
+    public fun core_fmt_rt_argument_new_display_i32(value: Int): String {
+        // Convert the integer to a string.
+        return value.toString()
+    }
+
+    @JvmStatic
+    public fun core_fmt_rt_argument_new_display(value: Any?): String {
+        // Convert the value to a string.
+        return value?.toString() ?: "null"
+    }
+
+    @JvmStatic
+    public fun core_fmt_rt_argument_new_display_bool(value: Boolean): String {
+        // Convert the boolean to a string.
+        return value.toString()
+    }
+
+    @JvmStatic
+    public fun core_fmt_rt_argument_new_display_f64(value: Double): String {
+        // Convert the double to a string.
+        return value.toString()
+    }
+
+    @JvmStatic
+    public fun arguments_new_v1(pieces: Array<String>, args: Array<Any?>): String {
+        val sb = StringBuilder()
+        var argIndex = 0
+        for (i in pieces.indices) {
+            sb.append(pieces[i]) // Append static piece
+            if (argIndex < args.size) {
+                // Append the corresponding argument (already formatted or convertible via toString)
+                sb.append(args[argIndex]?.toString() ?: "null")
+                argIndex++
+            }
+        }
+        return sb.toString()
+    }
 }

shim-metadata-gen/core.json

@@ -3,6 +3,26 @@
     "descriptor": "([Ljava/lang/String;)Ljava/lang/String;",
     "is_static": true
   },
+  "core_fmt_rt_argument_new_display_i32": {
+    "descriptor": "(I)Ljava/lang/String;",
+    "is_static": true
+  },
+  "core_fmt_rt_argument_new_display": {
+    "descriptor": "(Ljava/lang/Object;)Ljava/lang/String;",
+    "is_static": true
+  },
+  "core_fmt_rt_argument_new_display_f64": {
+    "descriptor": "(D)Ljava/lang/String;",
+    "is_static": true
+  },
+  "core_fmt_rt_argument_new_display_bool": {
+    "descriptor": "(Z)Ljava/lang/String;",
+    "is_static": true
+  },
+  "arguments_new_v1": {
+    "descriptor": "([Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
+    "is_static": true
+  },
   "panic_fmt": {
     "descriptor": "(Ljava/lang/String;)V",
     "is_static": true