chore: Merge branch 'feat/intermediate-trait'

Author: alemidev

.github/workflows/test.yml

@@ -2,8 +2,6 @@ name: test
 
 on:
   push:
-    branches:
-      - dev
 
 env:
   CARGO_TERM_COLOR: always
@@ -28,3 +26,5 @@ jobs:
           toolchain: ${{ matrix.toolchain }}
       - run: cargo build --verbose
       - run: cargo test --verbose
+      - uses: gradle/actions/setup-gradle@v4
+      - run: gradle test

.gitignore

@@ -1 +1,10 @@
+# rust
 /target
+
+# gradle
+/build
+/bin
+/.settings
+/.gradle
+.project
+.classpath

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["macro"]
+members = ["macro", "src/test"]
 
 [package]
 name = "jni-toolbox"
@@ -13,6 +13,11 @@ version = "0.1.3"
 edition = "2021"
 
 [dependencies]
-jni-toolbox-macro = "0.1.3"
+#jni-toolbox-macro = "0.1.3"
+jni-toolbox-macro = { path = "./macro" }
 jni = "0.21"
 uuid = { version = "1.10", optional = true }
+
+[features]
+default = []
+uuid = ["dep:uuid"]

Cargo.toml

@@ -3,13 +3,12 @@
 [![Crates.io Version](https://img.shields.io/crates/v/jni-toolbox)](https://crates.io/crates/jni-toolbox)
 [![docs.rs](https://img.shields.io/docsrs/jni-toolbox)](https://docs.rs/jni-toolbox)
 
+This is a simple crate built around [jni-rs](https://github.com/jni-rs/jni-rs) to automatically generate JNI-compatible extern functions.
 
-this is a simple crate built around [jni-rs](https://github.com/jni-rs/jni-rs) to automatically generate JNI-compatible extern functions
+It also wraps functions returning `Result<>`, making short-circuiting easy.
 
-it also wraps functions returning `Result<>`, making short-circuiting easy
-
-## usage
-just specify package and class on your function, and done!
+## Usage
+Just specify package and class on your function, and done!
 
 ```rust
 #[jni_toolbox::jni(package = "your.package.path", class = "ContainerClass")]
@@ -18,30 +17,28 @@ fn your_function_name(arg: String) -> Result<Vec<String>, String> {
 }
 ```
 
-### conversions
-every type that must go into/from Java must implement `IntoJava` or `FromJava` (methods will receive a `&mut JNIEnv` and can return errors).
-most primitives already have them implemented. conversions are automatic and the wrapper function will invoke IntoJava/FromJava for every type,
-passing an environment reference.
+### Conversions
+Every type that is meant to be sent to Java must implement `IntoJavaObject` (or, unlikely, `IntoJavaPrimitive`); every type that is meant to be
+received from Java must implement `FromJava`. Most primitives and a few common types should already be implemented.
 
 ```rust
-impl<'j> IntoJava for MyClass {
-  type T = jni::sys::jobject;
+impl<'j> IntoJavaObject for MyClass {
+  type T = jni::objects::JObject<'j>
   fn into_java(self, env: &mut jni::JNIEnv<'j>) -> Result<Self::T, jni::errors::Error> {
     let hello = env.new_string("world")?;
     // TODO!!
   }
 }
 ```
 
-### pointers
-to return pointer type values, add the `ptr` attribute
-
-note that, while possible to pass raw pointers to the JVM, it is not safe by default and must be done with extreme care.
+### Pointers
+Note that, while it is possible to pass raw pointers to the JVM, it is not safe by default and must be done with extreme care.
 
-### exceptions
+### Exceptions
 Errors are thrown automatically when a `Result` is an error. For your errors to work, you must implement the `JniToolboxError` trait for your errors,
 (which just returns the path to your Java error class) and then make a Java error wrapper which can be constructed with a single string argument.
-functions returning `Result`s will automatically have their return value unwrapped and, if is an err, throw an exception and return early.
+
+Functions returning `Result`s will automatically have their return value unwrapped and, if is an err, throw an exception and return early.
 
 ```rust
 impl JniToolboxError for MyError {
@@ -53,113 +50,75 @@ impl JniToolboxError for MyError {
 
 ```java
 package my.package.some;
-public class MyError {
+public class MyError extends Throwable {
   public MyError(String x) {
     // TODO
   }
 }
 ```
 
-to throw simple exceptions, it's possible to use the `exception` attribute. just pass your exception's path (must be constructable with a single string argument!)
-
+To throw simple exceptions, it's possible to use the `exception` attribute. Pass the exception's fully qualified name (must have a constructor
+that takes in a single `String` argument).
 
-
-### examples
-the following function:
+### Examples
+The following function:
 ```rust
 #[jni(package = "mp.code", class = "Client", ptr)]
 fn connect(config: Config) -> Result<Client, ConnectionError> {
-  tokio().block_on(Client::connect(config))
+  super::tokio().block_on(Client::connect(config))
 }
 ```
 
-gets turned into these two functions:
-
-<details><summary>show macro expansion</summary>
+generates a matching expanded function invoking it:
 
 ```rust
 fn connect(config: Config) -> Result<Client, ConnectionError> {
-  tokio().block_on(Client::connect(config))
+  super::tokio().block_on(Client::connect(config))
 }
 
 #[no_mangle]
-#[allow(unused_mut)]
+#[allow(unused_unit)]
 pub extern "system" fn Java_mp_code_Client_connect<'local>(
   mut env: jni::JNIEnv<'local>,
   _class: jni::objects::JClass<'local>,
-  mut config: <Config as jni_toolbox::FromJava<'local>>::T,
-) -> <Client as jni_toolbox::IntoJava<'local>>::T {
+  config: <Config as jni_toolbox::FromJava<'local>>::From,
+) -> <Client as jni_toolbox::IntoJava<'local>>::Ret {
   use jni_toolbox::{FromJava, IntoJava, JniToolboxError};
-  let mut env_copy = unsafe { env.unsafe_clone() };
   let config_new = match jni_toolbox::from_java_static::<Config>(&mut env, config) {
     Ok(x) => x,
     Err(e) => {
-      let _ = env.throw_new(
-        "java/lang/RuntimeException",
-        $crate::__export::must_use({
-          let res = $crate::fmt::format($crate::__export::format_args!("{e:?}"));
-          res
-        }),
-      );
+      let _ = env.throw_new(e.jclass(), format!("{e:?}"));
       return std::ptr::null_mut();
     }
   };
-  match connect(config_new) {
-    Err(e) => match env_copy.find_class(e.jclass()) {
-      Err(e) => {
-        $crate::panicking::panic_fmt($crate::const_format_args!(
-          "error throwing Java exception -- failed resolving error class: {e}"
-        ));
-      }
-      Ok(class) => match env_copy.new_string($crate::__export::must_use({
-        let res = $crate::fmt::format($crate::__export::format_args!("{e:?}"));
-        res
-      })) {
-        Err(e) => {
-          $crate::panicking::panic_fmt($crate::const_format_args!(
-            "error throwing Java exception --  failed creating error string: {e}"
-          ));
-        }
-        Ok(msg) => match env_copy.new_object(
-          class,
-          "(Ljava/lang/String;)V",
-          &[jni::objects::JValueGen::Object(&msg)],
-        ) {
-          Err(e) => {
-            $crate::panicking::panic_fmt($crate::const_format_args!(
-              "error throwing Java exception -- failed creating object: {e}"
-            ));
-          }
-          Ok(obj) => match env_copy.throw(jni::objects::JThrowable::from(obj)) {
-            Err(e) => {
-              $crate::panicking::panic_fmt($crate::const_format_args!(
-                "error throwing Java exception -- failed throwing: {e}"
-              ));
-            }
+  let result = connect(config_new);
+  let ret = match result {
+    Ok(x) => x,
+    Err(e) => match env.find_class(e.jclass()) {
+      Err(e) => panic!("error throwing Java exception -- failed resolving error class: {e}"),
+      Ok(class) => match env.new_string(format!("{e:?}")) {
+        Err(e) => panic!("error throwing Java exception --  failed creating error string: {e}"),
+        Ok(msg) => match env.new_object(class, "(Ljava/lang/String;)V", &[jni::objects::JValueGen::Object(&msg)]) {
+          Err(e) => panic!("error throwing Java exception -- failed creating object: {e}"));
+          Ok(obj) => match env.throw(jni::objects::JThrowable::from(obj)) {
+            Err(e) => panic!("error throwing Java exception -- failed throwing: {e}"),
             Ok(_) => return std::ptr::null_mut(),
           },
         },
       },
     },
-    Ok(ret) => match ret.into_java(&mut env_copy) {
-      Ok(fin) => return fin,
-      Err(e) => {
-        let _ = env_copy.throw_new(
-          "java/lang/RuntimeException",
-          $crate::__export::must_use({
-            let res = $crate::fmt::format($crate::__export::format_args!("{e:?}"));
-            res
-          }),
-        );
-        return std::ptr::null_mut();
-      }
-    },
+  };
+  match ret.into_java(&mut env) {
+    Ok(fin) => fin,
+    Err(e) => {
+      let _ = env.throw_new(e.jclass(), format!("{e:?}"));
+      std::ptr::null_mut()
+    }
   }
 }
 ```
 
-</details>
-
-
-## status
-this crate is rather early and intended mostly to maintain [`codemp`](https://github.com/hexedtech/codemp) java bindings, however it's also quite small and only runs at comptime, so should be rather safe to use
+## Status
+This crate is early and intended mostly to maintain [`codemp`](https://github.com/hexedtech/codemp)'s Java bindings, so things not used
+there may be missing or slightly broken. However, the crate is also quite small and only runs at compile time, so trying it out in your
+own project should not be a problem.

README.md

@@ -0,0 +1,24 @@
+plugins {
+	id 'java-library'
+}
+
+dependencies {
+	testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1'
+	testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1'
+}
+
+repositories {
+	mavenCentral()
+}
+
+task cargoBuild(type: Exec) {
+	workingDir '.'
+	commandLine 'cargo', 'build', '-p', 'jni-toolbox-test'
+}
+
+test {
+	dependsOn cargoBuild
+	outputs.upToDateWhen { false }
+	useJUnitPlatform()
+	systemProperty 'java.library.path','target/debug'
+}

build.gradle

@@ -22,31 +22,33 @@ fn unpack_pat(pat: syn::Pat) -> Result<TokenStream, syn::Error> {
 	}
 }
 
-fn type_equals(ty: Box<syn::Type>, search: impl AsRef<str>) -> bool {
+fn bare_type(ty: Box<syn::Type>) -> Option<syn::TypePath> {
 	match *ty {
-		syn::Type::Array(_) => false,
-		syn::Type::BareFn(_) => false,
-		syn::Type::ImplTrait(_) => false,
-		syn::Type::Infer(_) => false,
-		syn::Type::Macro(_) => false,
-		syn::Type::Never(_) => false,
-		syn::Type::Ptr(_) => false,
-		syn::Type::Slice(_) => false,
-		syn::Type::TraitObject(_) => false,
-		syn::Type::Tuple(_) => false,
-		syn::Type::Verbatim(_) => false,
-		syn::Type::Group(g) => type_equals(g.elem, search),
-		syn::Type::Paren(p) => type_equals(p.elem, search),
-		syn::Type::Reference(r) => type_equals(r.elem, search),
-		syn::Type::Path(ty) => {
-			ty.path.segments
-				.last()
-				.map_or(false, |e| e.ident == search.as_ref())
-		},
-		_ => false,
+		syn::Type::Array(a) => bare_type(a.elem),
+		syn::Type::BareFn(_) => None,
+		syn::Type::ImplTrait(_) => None,
+		syn::Type::Infer(_) => None,
+		syn::Type::Macro(_) => None,
+		syn::Type::Never(_) => None,
+		syn::Type::TraitObject(_) => None,
+		syn::Type::Verbatim(_) => None,
+		syn::Type::Ptr(p) => bare_type(p.elem),
+		syn::Type::Slice(s) => bare_type(s.elem),
+		syn::Type::Tuple(t) => bare_type(Box::new(t.elems.first()?.clone())), // TODO
+		syn::Type::Group(g) => bare_type(g.elem),
+		syn::Type::Paren(p) => bare_type(p.elem),
+		syn::Type::Reference(r) => bare_type(r.elem),
+		syn::Type::Path(ty) => Some(ty),
+		_ => todo!(),
 	}
 }
 
+fn type_equals(ty: Box<syn::Type>, search: impl AsRef<str>) -> bool {
+	let Some(ty) = bare_type(ty) else { return false };
+	let Some(last) = ty.path.segments.last() else { return false };
+	last.ident == search.as_ref()
+}
+
 impl ArgumentOptions {
 	pub(crate) fn parse_args(fn_item: &syn::ItemFn, ret_expr: TokenStream) -> Result<Self, syn::Error> {
 		let mut arguments = Vec::new();
@@ -83,9 +85,9 @@ impl ArgumentOptions {
 		if pass_env {
 			if let Some(arg) = args_iter.next() {
 				let pat = arg.pat;
-				let ty = arg.ty;
+				let ty = bare_type(arg.ty);
 				incoming.append_all(quote::quote!( mut #pat: #ty,));
-				forwarding.append_all(quote::quote!( #pat,));
+				forwarding.append_all(quote::quote!( &mut #pat,));
 			}
 		} else {
 			incoming.append_all(quote::quote!( mut #env: jni::JNIEnv<'local>,));
@@ -104,12 +106,12 @@ impl ArgumentOptions {
 					Ok(x) => x,
 					Err(e) => {
 						// TODO should we panic here instead?
-						let _ = #env.throw_new("java/lang/RuntimeException", format!("{e:?}"));
+						let _ = #env.throw_new(e.jclass(), format!("{e:?}"));
 						return #ret_expr;
 					},
 				};
 			});
-			incoming.append_all(quote::quote!( mut #pat: <#ty as jni_toolbox::FromJava<'local>>::T,));
+			incoming.append_all(quote::quote!( #pat: <#ty as jni_toolbox::FromJava<'local>>::From,));
 			forwarding.append_all(quote::quote!( #new_pat,));
 		}