New test - binary search

Author: IntegralPilot

Readme.md

@@ -24,14 +24,14 @@ Compile your Rust code into a runnable `.jar` on JVM 8+!
 ---
 
 ## 🔥 Demos
-
-All examples live in `tests/binary` and are compiled to JVM bytecode & run/tested on the CI on every commit. Some exicting demos made in pure-Rust include:
-
-- **RSA** encryption/decryption (`rsa`) 
-- **Fibonacci** sequence generator (`fibonacci`)  
-- **Collatz conjecture** verifier (`collatz`)  
-- **Large prime** generator (`primes`)
-- Nested data structures: enums, structs, tuples, arrays, slices (`enums`, `structs`)  
+All examples live in `tests/binary` and are compiled to JVM bytecode & run/tested on the CI on every commit. Some exciting demos made in pure-Rust include:
+
+- **[RSA](tests/binary/rsa/src/main.rs)** encryption/decryption  
+- **[Binary search](tests/binary/binsearch/src/main.rs)** algorithm  
+- **[Fibonacci](tests/binary/fibonacci/src/main.rs)** sequence generator  
+- **[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)  
 - …and more!
 
 ---
@@ -95,7 +95,7 @@ This will compile:
 - `rustc_codegen_jvm` backend library  
 - `java-linker`  
 - `asm-processor`  
-- Kotlin shim for `core`  
+- Kotlin shim for `core` (once core support is reached, this will no longer be needed)  
 - Generate `config.toml` & `jvm-unknown-unknown.json`  
 
 If you relocate the repo, re-run:
@@ -108,17 +108,17 @@ make gen-files
 ## 🚀 Usage
 
 1. **Configure your project**  
-   In *your* Rust project directory, create or update `.cargo/config.toml` with the generated template.
+   In *your* Rust project directory, create or update `.cargo/config.toml` with the generated template (will be at the root of this repo after running make).
 
 2. **Build with Cargo**  
    ```bash
    cargo build           # debug
-   cargo build --release # optimized
+   cargo build --release # optimized - functionality available slightly impaired 
    ```
 
 3. **Run the `.jar`**  
    ```bash
-   java -jar target/debug/deps/your_crate.jar
+   java -jar target/debug/deps/your_crate*.jar
    ```
 
 ---

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

@@ -219,4 +219,29 @@ public object Core {
         }
     }
 
+    @JvmStatic
+    // same as unwrap but return true/false if None instead of exception
+    public fun option_is_none(optionObj: Any?): Boolean {
+        if (optionObj == null) {
+            // This shouldn't happen if the codegen is correct, as unwrap is called on an instance.
+            panic_fmt("FATAL: Called option_is_none on a null reference. This indicates a bug in the code generator.")
+            // Need a return path for the compiler, even though panic throws.
+            throw RuntimeException("Unreachable after panic")
+        }
+
+        // Determine the variant using instanceof (Kotlin 'is')
+        if (optionObj::class.java.name.endsWith("option\$some")) {
+            // It's Some(value). Return false.
+            return false
+        } else if (optionObj::class.java.name.endsWith("option\$none")) {
+            // It's None. Return true.
+            return true
+        } else {
+            // Input object was not an expected Option variant. This indicates a codegen bug.
+            val className = optionObj::class.java.name
+            panic_fmt("Internal Compiler Error: Called option_is_none on an unexpected type: $className. Expected type ending in option\$some or option\$none.")
+            throw RuntimeException("Unreachable after panic") // For compiler
+        }
+    }
+
 }

shim-metadata-gen/core.json

@@ -43,6 +43,10 @@
     "descriptor": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
     "is_static": true
   },
+  "option_is_none": {
+    "descriptor": "(Ljava/lang/Object;)Z",
+    "is_static": true
+  },
   "option_unwrap": {
     "descriptor": "(Ljava/lang/Object;)Ljava/lang/Object;",
     "is_static": true

src/lower1/operand.rs

@@ -426,13 +426,22 @@ pub fn handle_const_value<'tcx>(
                                                 }
                                             } else {
                                                 /* Array element type is not Ref */
-                                                println!(
-                                                    "Warning: Scalar::Ptr points to Ref-to-Array where element type {:?} is not a reference.",
-                                                    elem_ty
-                                                );
-                                                return oomir::Operand::Constant(
-                                                    oomir::Constant::I64(-5),
-                                                ); // Indicate wrong element type
+                                                match read_constant_value_from_memory(tcx, allocation, pointer.into_parts().1, *inner_ty, data_types) {
+                                                    Ok(oomir_const) => {
+                                                        println!(
+                                                            "Info: Successfully read constant value from memory: {:?}",
+                                                            oomir_const
+                                                        );
+                                                        return oomir::Operand::Constant(oomir_const);
+                                                    }
+                                                    Err(e) => {
+                                                        println!(
+                                                            "Warning: Failed to read constant value from memory for allocation {:?}. Error: {:?}",
+                                                            alloc_id, e
+                                                        );
+                                                        return oomir::Operand::Constant(oomir::Constant::I32(-1))
+                                                    }
+                                                }
                                             }
                                         } else {
                                             // Could not determine array length (e.g., generic)

src/lower1/types.rs

@@ -163,6 +163,11 @@ pub fn ty_to_oomir_type<'tcx>(
             // Default slice handling
             oomir::Type::Array(Box::new(ty_to_oomir_type(*component_ty, tcx, data_types)))
         }
+        rustc_middle::ty::TyKind::Never => {
+            // Handle the never type
+            println!("Info: Mapping Never type to OOMIR Void");
+            oomir::Type::Void
+        }
         _ => {
             println!("Warning: Unhandled type {:?}", ty);
             oomir::Type::Class("UnsupportedType".to_string())

src/lower2/helpers.rs

@@ -602,7 +602,7 @@ pub fn parse_jvm_descriptor_return(descriptor: &str) -> Result<String, String> {
     println!("Parsing return type from descriptor: {}", descriptor);
 
     // 1. find the parentheses
-    let open_paren = descriptor
+    descriptor
         .find('(')
         .ok_or_else(|| "Descriptor must start with '('".to_string())?;
     let close_paren = descriptor

tests/binary/binsearch/.cargo/config.toml

@@ -0,0 +1 @@
+../../../../config.toml

tests/binary/binsearch/Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "binsearch"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

tests/binary/binsearch/Cargo.toml

@@ -0,0 +1,36 @@
+/// Binary search for u32 slices.
+/// Returns `Some(index)` if `target` is found, or `None` otherwise.
+pub fn binary_search(slice: &[u32], target: u32) -> Option<usize> {
+    let mut low = 0;
+    let mut high = slice.len();
+
+    while low < high {
+        // mid = floor((low + high) / 2) without overflow
+        let mid = low + (high - low) / 2;
+        let v = slice[mid];
+        if v < target {
+            low = mid + 1;
+        } else if v > target {
+            high = mid;
+        } else {
+            return Some(mid);
+        }
+    }
+
+    None
+}
+
+fn main() {
+    // demo array (must be sorted!)
+    let arr = [1, 2, 3, 5, 8, 13, 21];
+
+    // successful searches
+    assert!(binary_search(&arr, 1)  == Some(0));
+    assert!(binary_search(&arr, 5)  == Some(3));
+    assert!(binary_search(&arr, 21) == Some(6));
+
+    // unsuccessful searches
+    assert!(binary_search(&arr, 0).is_none());
+    assert!(binary_search(&arr, 4).is_none());
+    assert!(binary_search(&arr, 22).is_none());
+}