Support for assert! (supringly involved at lot, including a new OOMIR Switch instruction, a new Kotlin-based shim of core and a lot of new pointer constant handling logic)

Author: IntegralPilot

Makefile

@@ -1,8 +1,8 @@
 # Makefile
 
-.PHONY: all rust java-linker asm-processor clean clean-rust clean-java-linker clean-asm-processor
+.PHONY: all rust java-linker asm-processor clean clean-rust clean-java-linker clean-asm-processor library clean-library
 
-all: rust java-linker asm-processor
+all: rust java-linker asm-processor library
 
 # --- Rust root project ---
 rust:
@@ -25,5 +25,11 @@ asm-processor:
 clean-asm-processor:
 	cd asm-processor && gradle clean
 
+# --- Standard Library Shim (Gradle) ---
+library:
+	cd library && gradle build
+clean-library:
+	cd library && gradle clean
+
 # --- Clean everything ---
-clean: clean-rust clean-java-linker clean-asm-processor
+clean: clean-rust clean-java-linker clean-asm-processor clean-library

Readme.md

@@ -134,6 +134,7 @@ This project includes integration tests managed by a Python script.
 *   `asm-processor/`: Kotlin/Gradle project for the ASM-based bytecode post-processor that adds stack map frames to the generated `.class` files.
 *   `tests/`: Integration tests.
     *   `binary/`: Tests for compiling executable Rust crates.
+*   `library/`: Source code for a minimal Kotlin-based implementation of the Rust core library. This serves as a temporary substitute to bootstrap the project until the backend can fully compile the Rust core library itself.
 *   `jvm-unknown-unknown.json`: The Rust target specification file.
 *   `Tester.py`: Python script for running integration tests.
 *   `Makefile`, `build.sh`: Scripts for building the entire toolchain.

build.sh

@@ -1,11 +1,11 @@
 use std::env;
 use std::fs;
-use std::io::{self, Write};
+use std::io::{self, Write, Read};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use regex::Regex;
 use zip::write::{SimpleFileOptions, ZipWriter};
-use zip::CompressionMethod;
+use zip::{CompressionMethod, ZipArchive};
 use tempfile::NamedTempFile;
 
 fn main() -> Result<(), i32> {
@@ -129,6 +129,23 @@ fn find_main_classes(class_files: &[String]) -> Vec<String> {
     main_classes
 }
 
+fn process_jar_file(jar_path: &str) -> io::Result<Vec<(String, Vec<u8>)>> {
+    let jar_file = fs::File::open(jar_path)?;
+    let mut archive = ZipArchive::new(jar_file)?;
+    let mut class_files = Vec::new();
+
+    for i in 0..archive.len() {
+        let mut file = archive.by_index(i)?;
+        if file.name().ends_with(".class") {
+            let mut contents = Vec::new();
+            file.read_to_end(&mut contents)?;
+            class_files.push((file.name().to_string(), contents));
+        }
+    }
+
+    Ok(class_files)
+}
+
 fn create_jar(
     input_files: &[String],
     output_jar_path: &str,
@@ -148,61 +165,100 @@ fn create_jar(
 
     let re = Regex::new(r"^(.*?)-[0-9a-f]+(\.class)$").unwrap();
 
-    for input_file_path_str in input_files {
-        let input_path = Path::new(input_file_path_str);
-        let original_file_name = input_path.file_name()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, format!("Invalid input path: {}", input_file_path_str)))?
-            .to_str()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "Input filename is not valid UTF-8"))?;
+    // Track all class files we've added to avoid duplicates
+    let mut added_class_files = std::collections::HashSet::new();
 
-        let jar_entry_name = if let Some(caps) = re.captures(original_file_name) {
-            format!("{}{}", &caps[1], &caps[2])
-        } else {
-            original_file_name.to_string()
-        };
+    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) {
+                    let processed_data = if let Some(processor_path) = processor_jar_path {
+                        let temp_out_file = NamedTempFile::new()?;
+                        let temp_in_file = NamedTempFile::new()?;
+                        fs::write(&temp_in_file, &class_data)?;
 
-        let file_data_to_add: Vec<u8>;
-        let mut _temp_file_handle: Option<NamedTempFile> = None;
+                        let temp_out_path = temp_out_file.path().to_path_buf();
+                        let temp_in_path = temp_in_file.path().to_path_buf();
 
-        if input_file_path_str.ends_with(".class") {
-            println!("Processing class file: {}", input_file_path_str);
+                        let mut cmd = Command::new("java");
+                        cmd.arg("-jar")
+                           .arg(processor_path)
+                           .arg(&temp_in_path)
+                           .arg(&temp_out_path);
 
-            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();
+                        println!("Running processor on {}: {:?}", class_path, cmd);
+                        let output = cmd.output()?;
 
-                let mut cmd = Command::new("java");
-                cmd.arg("-jar")
-                   .arg(processor_path)
-                   .arg(input_file_path_str)
-                   .arg(&temp_out_path);
+                        if !output.status.success() {
+                            eprintln!("Error processing file from JAR: {}", class_path);
+                            eprintln!("Processor STDOUT:\n{}", String::from_utf8_lossy(&output.stdout));
+                            eprintln!("Processor STDERR:\n{}", String::from_utf8_lossy(&output.stderr));
+                            return Err(io::Error::new(io::ErrorKind::Other, "ASM processor failed"));
+                        }
 
-                println!("Running processor: {:?}", cmd);
-                let output = cmd.output()?;
+                        fs::read(&temp_out_path)?
+                    } else {
+                        class_data
+                    };
 
-                if !output.status.success() {
-                    eprintln!("Error processing file: {}", input_file_path_str);
-                    eprintln!("Processor STDOUT:\n{}", String::from_utf8_lossy(&output.stdout));
-                    eprintln!("Processor STDERR:\n{}", String::from_utf8_lossy(&output.stderr));
-                    return Err(io::Error::new(io::ErrorKind::Other, "ASM processor failed"));
+                    zip_writer.start_file(&class_path, options)?;
+                    zip_writer.write_all(&processed_data)?;
+                    added_class_files.insert(class_path.clone());
+                    println!("Added class from JAR: {}", class_path);
                 }
+            }
+        } else if input_file_path_str.ends_with(".class") {
+            let input_path = Path::new(input_file_path_str);
+            let original_file_name = input_path.file_name()
+                .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, format!("Invalid input path: {}", input_file_path_str)))?
+                .to_str()
+                .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "Input filename is not valid UTF-8"))?;
 
-                let processed_data = fs::read(&temp_out_path)?;
-                _temp_file_handle = Some(temp_out_file);
-                processed_data
+            let jar_entry_name = if let Some(caps) = re.captures(original_file_name) {
+                format!("{}{}", &caps[1], &caps[2])
             } else {
-                fs::read(input_file_path_str)?
+                original_file_name.to_string()
             };
 
-            file_data_to_add = file_data;
-            println!("Successfully processed: {}", input_file_path_str);
+            if !added_class_files.contains(&jar_entry_name) {
+                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();
+
+                    let mut cmd = Command::new("java");
+                    cmd.arg("-jar")
+                       .arg(processor_path)
+                       .arg(input_file_path_str)
+                       .arg(&temp_out_path);
+
+                    println!("Running processor: {:?}", cmd);
+                    let output = cmd.output()?;
+
+                    if !output.status.success() {
+                        eprintln!("Error processing file: {}", input_file_path_str);
+                        eprintln!("Processor STDOUT:\n{}", String::from_utf8_lossy(&output.stdout));
+                        eprintln!("Processor STDERR:\n{}", String::from_utf8_lossy(&output.stderr));
+                        return Err(io::Error::new(io::ErrorKind::Other, "ASM processor failed"));
+                    }
+
+                    fs::read(&temp_out_path)?
+                } else {
+                    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);
+                println!("Successfully processed: {}", input_file_path_str);
+            }
         } else {
-            println!("Skipping non-class file: {}", input_file_path_str);
-            continue;
+            println!("Skipping non-class/jar file: {}", input_file_path_str);
         }
-
-        zip_writer.start_file(&jar_entry_name, options)?;
-        zip_writer.write_all(&file_data_to_add)?;
     }
 
     zip_writer.finish()?;

java-linker/src/main.rs

@@ -0,0 +1,15 @@
+plugins {
+    kotlin("jvm") version "2.1.20"
+    application
+}
+
+group = "org.rustlang"
+version = "0.1.0"
+
+repositories {
+    mavenCentral()
+}
+
+kotlin {
+    jvmToolchain(21) // latest LTS. note to self: update when they release a new LTS.
+}

library/build.gradle.kts

@@ -0,0 +1,18 @@
+package org.rustlang.core
+
+/**
+ * Core functions needed by the Rust JVM backend stdlib shim.
+ */
+public object Core {
+
+    @JvmStatic // Ensures static JVM methods are generated
+    public fun rust_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>"))
+    }
+
+    @JvmStatic
+    public fun rust_fmt_arguments_new_const_stub(messagePiece: String?): String? {
+        return messagePiece
+    }
+}

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

@@ -10,6 +10,7 @@
 //! Compiler backend for rustc that generates JVM bytecode, using a two-stage lowering process:
 //! MIR -> OOMIR -> JVM Bytecode.
 
+extern crate rustc_abi;
 extern crate rustc_codegen_ssa;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
@@ -24,16 +25,16 @@ use rustc_codegen_ssa::{
     CodegenResults, CompiledModule, CrateInfo, ModuleKind, traits::CodegenBackend,
 };
 
-use rustc_metadata::EncodedMetadata;
 use rustc_data_structures::fx::FxIndexMap;
+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};
 
-mod oomir;
 mod lower1;
 mod lower2;
+mod oomir;
 
 /// An instance of our Java bytecode codegen backend.
 struct MyBackend;
@@ -84,19 +85,24 @@ impl CodegenBackend for MyBackend {
                 let oomir_function = lower1::mir_to_oomir(tcx, instance, &mut mir);
                 println!("--- Finished MIR to OOMIR Lowering for function: {i} ---");
 
-                println!("OOMIR is: {:?}", oomir_function);
-
-                oomir_module.functions.insert(oomir_function.name.clone(), oomir_function);
+                oomir_module
+                    .functions
+                    .insert(oomir_function.name.clone(), oomir_function);
             }
         }
 
         println!("OOMIR module: {:?}", oomir_module);
 
-        println!("--- Starting OOMIR to JVM Bytecode Lowering for module: {} ---", crate_name);
+        println!(
+            "--- Starting OOMIR to JVM Bytecode Lowering for module: {} ---",
+            crate_name
+        );
         let bytecode = lower2::oomir_to_jvm_bytecode(&oomir_module, tcx).unwrap();
         //let bytecode = vec![0; 1024];
-        println!("--- Finished OOMIR to JVM Bytecode Lowering for module: {} ---", crate_name);
-
+        println!(
+            "--- Finished OOMIR to JVM Bytecode Lowering for module: {} ---",
+            crate_name
+        );
 
         Box::new((
             bytecode,
@@ -117,8 +123,6 @@ impl CodegenBackend for MyBackend {
                 .downcast::<(Vec<u8>, String, EncodedMetadata, CrateInfo)>()
                 .expect("in join_codegen: ongoing_codegen is not bytecode vector");
 
-            println!("going to write: {:?}", bytecode);
-
             let class_path = outputs.temp_path_ext("class", None);
 
             let mut class_file =
@@ -172,7 +176,6 @@ pub fn custom_alloc_error_hook(layout: Layout) {
     panic!("Memory allocation failed: {} bytes", layout.size());
 }
 
-
 struct RlibArchiveBuilder;
 impl ArchiveBuilderBuilder for RlibArchiveBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a> {
@@ -190,4 +193,4 @@ impl ArchiveBuilderBuilder for RlibArchiveBuilder {
     ) {
         unimplemented!("creating dll imports is not supported");
     }
-}
+}