[INFO] fetching crate rust_swig 0.5.1... [INFO] checking rust_swig-0.5.1 against master#350d0ef0ec0493e6d21cfb265cb8211a0e74d766 for pr-145342-1 [INFO] extracting crate rust_swig 0.5.1 into /workspace/builds/worker-5-tc1/source [INFO] started tweaking crates.io crate rust_swig 0.5.1 [INFO] finished tweaking crates.io crate rust_swig 0.5.1 [INFO] tweaked toml for crates.io crate rust_swig 0.5.1 written to /workspace/builds/worker-5-tc1/source/Cargo.toml [INFO] validating manifest of crates.io crate rust_swig 0.5.1 on toolchain 350d0ef0ec0493e6d21cfb265cb8211a0e74d766 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+350d0ef0ec0493e6d21cfb265cb8211a0e74d766" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+350d0ef0ec0493e6d21cfb265cb8211a0e74d766" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Blocking waiting for file lock on package cache [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 67 packages to latest compatible versions [INFO] [stderr] Adding bitflags v1.3.2 (available: v2.9.3) [INFO] [stderr] Adding env_logger v0.7.1 (available: v0.11.8) [INFO] [stderr] Adding heck v0.3.3 (available: v0.5.0) [INFO] [stderr] Adding jni-sys v0.3.0 (available: v0.4.0) [INFO] [stderr] Adding petgraph v0.5.1 (available: v0.8.2) [INFO] [stderr] Adding pulldown-cmark v0.7.2 (available: v0.13.0) [INFO] [stderr] Adding rustc-hash v1.1.0 (available: v2.1.1) [INFO] [stderr] Adding smol_str v0.1.24 (available: v0.3.2) [INFO] [stderr] Adding strum v0.18.0 (available: v0.27.2) [INFO] [stderr] Adding syn v1.0.109 (available: v2.0.106) [INFO] [stderr] Adding which v3.1.1 (available: v8.0.0) [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+350d0ef0ec0493e6d21cfb265cb8211a0e74d766" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Blocking waiting for file lock on package cache [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:7ad1b28ee6f5f7f699f6cf7015098d6ccdd96d6f2d78dd06228f5b4c9faf309c" "/opt/rustwide/cargo-home/bin/cargo" "+350d0ef0ec0493e6d21cfb265cb8211a0e74d766" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] a4843fd3ecceeb5f0f0cfb8743fc4d981ae1c33c433aa7581c49d8e9fe176e64 [INFO] running `Command { std: "docker" "start" "-a" "a4843fd3ecceeb5f0f0cfb8743fc4d981ae1c33c433aa7581c49d8e9fe176e64", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "a4843fd3ecceeb5f0f0cfb8743fc4d981ae1c33c433aa7581c49d8e9fe176e64", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "a4843fd3ecceeb5f0f0cfb8743fc4d981ae1c33c433aa7581c49d8e9fe176e64", kill_on_drop: false }` [INFO] [stdout] a4843fd3ecceeb5f0f0cfb8743fc4d981ae1c33c433aa7581c49d8e9fe176e64 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:7ad1b28ee6f5f7f699f6cf7015098d6ccdd96d6f2d78dd06228f5b4c9faf309c" "/opt/rustwide/cargo-home/bin/cargo" "+350d0ef0ec0493e6d21cfb265cb8211a0e74d766" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] c19384dd95f45e554266080c0dfa5c7ee823f347dcd78dfd2617ed2f4351af76 [INFO] running `Command { std: "docker" "start" "-a" "c19384dd95f45e554266080c0dfa5c7ee823f347dcd78dfd2617ed2f4351af76", kill_on_drop: false }` [INFO] [stderr] Compiling proc-macro2 v1.0.101 [INFO] [stderr] Compiling syn v1.0.109 [INFO] [stderr] Compiling unicode-ident v1.0.18 [INFO] [stderr] Compiling libc v0.2.175 [INFO] [stderr] Compiling autocfg v1.5.0 [INFO] [stderr] Checking memchr v2.7.5 [INFO] [stderr] Compiling unicode-segmentation v1.12.0 [INFO] [stderr] Compiling serde v1.0.219 [INFO] [stderr] Compiling getrandom v0.3.3 [INFO] [stderr] Checking regex-syntax v0.8.6 [INFO] [stderr] Compiling rustix v1.0.8 [INFO] [stderr] Checking hashbrown v0.12.3 [INFO] [stderr] Checking bitflags v1.3.2 [INFO] [stderr] Compiling pulldown-cmark v0.7.2 [INFO] [stderr] Checking quick-error v1.2.3 [INFO] [stderr] Checking linux-raw-sys v0.9.4 [INFO] [stderr] Checking bitflags v2.9.3 [INFO] [stderr] Checking unicode-width v0.2.1 [INFO] [stderr] Checking log v0.4.27 [INFO] [stderr] Checking cfg-if v1.0.3 [INFO] [stderr] Checking fixedbitset v0.2.0 [INFO] [stderr] Checking getopts v0.2.23 [INFO] [stderr] Compiling heck v0.3.3 [INFO] [stderr] Checking humantime v1.3.0 [INFO] [stderr] Checking smallvec v1.15.1 [INFO] [stderr] Checking termcolor v1.4.1 [INFO] [stderr] Checking lazy_static v1.5.0 [INFO] [stderr] Checking unicase v2.8.1 [INFO] [stderr] Checking rustc-hash v1.1.0 [INFO] [stderr] Compiling indexmap v1.9.3 [INFO] [stderr] Checking fastrand v2.3.0 [INFO] [stderr] Checking once_cell v1.21.3 [INFO] [stderr] Checking aho-corasick v1.1.3 [INFO] [stderr] Checking jni-sys v0.3.0 [INFO] [stderr] Checking atty v0.2.14 [INFO] [stderr] Checking which v3.1.1 [INFO] [stderr] Checking quote v1.0.40 [INFO] [stderr] Checking petgraph v0.5.1 [INFO] [stderr] Checking regex-automata v0.4.10 [INFO] [stderr] Checking tempfile v3.21.0 [INFO] [stderr] Checking smol_str v0.1.24 [INFO] [stderr] Checking regex v1.11.2 [INFO] [stderr] Checking env_logger v0.7.1 [INFO] [stderr] Compiling strum_macros v0.18.0 [INFO] [stderr] Compiling rust_swig v0.5.1 (/opt/rustwide/workdir) [INFO] [stderr] Checking strum v0.18.0 [INFO] [stdout] warning: method `name` is never used [INFO] [stdout] --> src/typemap/utils.rs:26:8 [INFO] [stdout] | [INFO] [stdout] 25 | pub(crate) trait ForeignTypeInfoT { [INFO] [stdout] | ---------------- method in this trait [INFO] [stdout] 26 | fn name(&self) -> &str; [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: method `output` is never used [INFO] [stdout] --> src/typemap/utils.rs:41:8 [INFO] [stdout] | [INFO] [stdout] 39 | pub(crate) trait ForeignMethodSignature { [INFO] [stdout] | ---------------------- method in this trait [INFO] [stdout] 40 | type FI: ForeignTypeInfoT; [INFO] [stdout] 41 | fn output(&self) -> &dyn ForeignTypeInfoT; [INFO] [stdout] | ^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `span` is never read [INFO] [stdout] --> src/types.rs:126:16 [INFO] [stdout] | [INFO] [stdout] 125 | pub(crate) struct FnDecl { [INFO] [stdout] | ------ field in this struct [INFO] [stdout] 126 | pub(crate) span: Span, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `FnDecl` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast.rs:721:41 [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec { [INFO] [stdout] | ^^^^^^^^^^^^^^ -------------------- the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec<'_> { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast/subst_map.rs:33:28 [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem] { [INFO] [stdout] | ^^^^^ -------------------- [INFO] [stdout] | | | | [INFO] [stdout] | | | the same lifetime is hidden here [INFO] [stdout] | | the same lifetime is elided here [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem<'_>] { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/typemap_macro.rs:193:9 [INFO] [stdout] | [INFO] [stdout] 193 | &self, [INFO] [stdout] | ^^^^^ the lifetime is elided here [INFO] [stdout] ... [INFO] [stdout] 197 | ) -> Option [INFO] [stdout] | ---------------- the same lifetime is hidden here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 197 | ) -> Option> [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: fields `ignore`, `no_run`, `should_panic`, and `template` are never read [INFO] [stdout] --> tests/test_code_in_readme.rs:69:5 [INFO] [stdout] | [INFO] [stdout] 66 | struct Test { [INFO] [stdout] | ---- fields in this struct [INFO] [stdout] ... [INFO] [stdout] 69 | ignore: bool, [INFO] [stdout] | ^^^^^^ [INFO] [stdout] 70 | no_run: bool, [INFO] [stdout] | ^^^^^^ [INFO] [stdout] 71 | should_panic: bool, [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] 72 | template: Option, [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `Test` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis [INFO] [stdout] = note: `#[warn(dead_code)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: static `JAVA_LANG_STRING` is never used [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-0713a779ed0133e0/out/jni-include.rs:59:1758 [INFO] [stdout] | [INFO] [stdout] 59 | ...TY : jmethodID = :: std :: ptr :: null_mut () ; static mut JAVA_LANG_STRING : jclass = :: std :: ptr :: null_mut () ; [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> /opt/rustwide/target/debug/build/rust_swig-0713a779ed0133e0/out/jni-include.rs:1:7405 [INFO] [stdout] | [INFO] [stdout] 1 | ... : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv... [INFO] [stdout] | ^^^^^^ ------------ the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 1 | macro_rules ! foreign_typemap { ($ ($ tree : tt) *) => { } ; } # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] # [doc = "swig_ replace"] mod swig_foreign_types_map { } # [allow (dead_code)] mod internal_aliases { use super :: * ; pub type JStringOptStr = jstring ; pub type JOptionalInt = jobject ; pub type JInteger = jobject ; pub type JByte = jobject ; pub type JShort = jobject ; pub type JFloat = jobject ; pub type JDouble = jobject ; pub type JOptionalDouble = jobject ; pub type JLong = jobject ; pub type JOptionalLong = jobject ; # [repr (transparent)] pub struct JForeignObjectsArray < T : SwigForeignClass > { pub (crate) inner : jobjectArray , pub (crate) _marker : :: std :: marker :: PhantomData < T > , } pub type JStringPath = jstring ; } # [doc = " Default JNI_VERSION"] const SWIG_JNI_VERSION : jint = JNI_VERSION_1_6 as jint ; # [doc = " Marker for what to cache in JNI_OnLoad"] # [allow (unused_macros)] macro_rules ! swig_jni_find_class { ($ id : ident , $ path : expr) => { unsafe { $ id } } ; ($ id : ident , $ path : expr ,) => { unsafe { $ id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_method_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (unused_macros)] macro_rules ! swig_jni_get_static_field_id { ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr) => { unsafe { $ global_id } } ; ($ global_id : ident , $ class_id : ident , $ name : expr , $ sig : expr ,) => { unsafe { $ global_id } } ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigInto < T > { fn swig_into (self , env : * mut JNIEnv) -> T ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigFrom < T > { fn swig_from (_ : T , env : * mut JNIEnv) -> Self ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDeref { type Target : ? Sized ; fn swig_deref (& self) -> & Self :: Target ; } # [allow (dead_code)] # [doc = "swig_ replace"] trait SwigDerefMut { type Target : ? Sized ; fn swig_deref_mut (& mut self) -> & mut Self :: Target ; } # [allow (unused_macros)] macro_rules ! swig_c_str { ($ lit : expr) => { concat ! ($ lit , "\0") . as_ptr () as * const :: std :: os :: raw :: c_char } ; } # [allow (unused_macros)] macro_rules ! swig_assert_eq_size { ($ x : ty , $ ($ xs : ty) ,+ $ (,) *) => { $ (let _ = :: std :: mem :: transmute ::<$ x , $ xs >;) + } ; } # [cfg (target_pointer_width = "32")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { (val as u32) as * mut T } # [cfg (target_pointer_width = "64")] pub unsafe fn jlong_to_pointer < T > (val : jlong) -> * mut T { val as * mut T } foreign_typemap ! ((r_type) () ; (f_type) "void" ;) ; foreign_typemap ! ((r_type) jbyte ; (f_type) "byte" ;) ; foreign_typemap ! ((r_type) jshort ; (f_type) "short" ;) ; foreign_typemap ! ((r_type) jint ; (f_type) "int" ;) ; foreign_typemap ! ((r_type) jlong ; (f_type) "long" ;) ; foreign_typemap ! ((r_type) jfloat ; (f_type) "float" ;) ; foreign_typemap ! ((r_type) jdouble ; (f_type) "double" ;) ; foreign_typemap ! ((r_type) jstring ; (f_type , option = "NoNullAnnotations") "String" ; (f_type , option = "NullAnnotations") "@NonNull String" ;) ; # [allow (dead_code)] pub trait SwigForeignClass { type PointedType ; fn jni_class () -> jclass ; fn jni_class_pointer_field () -> jfieldID ; fn box_object (x : Self) -> jlong ; fn unbox_object (x : jlong) -> Self ; fn to_pointer (x : jlong) -> :: std :: ptr :: NonNull < Self :: PointedType > ; } # [allow (dead_code)] pub trait SwigForeignCLikeEnum { fn as_jint (& self) -> jint ; # [doc = " # Panics"] # [doc = " Panics on error"] fn from_jint (_ : jint) -> Self ; } impl < T : SwigForeignCLikeEnum > SwigFrom < T > for jint { fn swig_from (x : T , _ : * mut JNIEnv) -> jint { x . as_jint () } } impl < T : SwigForeignCLikeEnum > SwigFrom < jint > for T { fn swig_from (x : jint , _ : * mut JNIEnv) -> T { T :: from_jint (x) } } # [allow (dead_code)] pub struct JavaString { string : jstring , chars : * const :: std :: os :: raw :: c_char , env : * mut JNIEnv , } # [allow (dead_code)] impl JavaString { pub fn new (env : * mut JNIEnv , js : jstring) -> JavaString { let chars = if ! js . is_null () { unsafe { (* * env) . GetStringUTFChars . unwrap () (env , js , :: std :: ptr :: null_mut ()) } } else { :: std :: ptr :: null_mut () } ; JavaString { string : js , chars : chars , env : env , } } pub fn to_str (& self) -> & str { if ! self . chars . is_null () { let s = unsafe { :: std :: ffi :: CStr :: from_ptr (self . chars) } ; s . to_str () . unwrap () } else { "" } } } # [allow (dead_code)] impl Drop for JavaString { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; if ! self . string . is_null () { assert ! (! self . chars . is_null ()) ; unsafe { (* * self . env) . ReleaseStringUTFChars . unwrap () (self . env , self . string , self . chars) } ; self . env = :: std :: ptr :: null_mut () ; self . chars = :: std :: ptr :: null_mut () ; } } } impl SwigDeref for JavaString { type Target = str ; fn swig_deref (& self) -> & Self :: Target { self . to_str () } } # [allow (dead_code)] struct JavaCallback { java_vm : * mut JavaVM , this : jobject , methods : Vec < jmethodID > , } # [doc = " According to JNI spec it should be safe to"] # [doc = " pass pointer to JavaVm and jobject (global) across threads"] unsafe impl Send for JavaCallback { } # [allow (dead_code)] struct JniEnvHolder < 'a > { env : Option < * mut JNIEnv > , callback : & 'a JavaCallback , need_detach : bool , } # [allow (dead_code)] impl < 'a > Drop for JniEnvHolder < 'a > { fn drop (& mut self) { if self . need_detach { let res = unsafe { (* * self . callback . java_vm) . DetachCurrentThread . unwrap () (self . callback . java_vm) } ; if res != 0 { log :: error ! ("JniEnvHolder: DetachCurrentThread failed: {}" , res) ; } } } } # [allow (dead_code)] impl JavaCallback { fn new (obj : jobject , env : * mut JNIEnv) -> JavaCallback { let mut java_vm : * mut JavaVM = :: std :: ptr :: null_mut () ; let ret = unsafe { (* * env) . GetJavaVM . unwrap () (env , & mut java_vm) } ; assert_eq ! (0 , ret , "GetJavaVm failed") ; let global_obj = unsafe { (* * env) . NewGlobalRef . unwrap () (env , obj) } ; assert ! (! global_obj . is_null ()) ; JavaCallback { java_vm , this : global_obj , methods : Vec :: new () , } } fn get_jni_env (& self) -> JniEnvHolder<'_> { assert ! (! self . java_vm . is_null ()) ; let mut env : * mut JNIEnv = :: std :: ptr :: null_mut () ; let res = unsafe { (* * self . java_vm) . GetEnv . unwrap () (self . java_vm , (& mut env) as * mut * mut JNIEnv as * mut * mut :: std :: os :: raw :: c_void , SWIG_JNI_VERSION ,) } ; if res == (JNI_OK as jint) { return JniEnvHolder { env : Some (env) , callback : self , need_detach : false , } ; } if res != (JNI_EDETACHED as jint) { panic ! ("get_jni_env: GetEnv return error `{}`" , res) ; } trait ConvertPtr < T > { fn convert_ptr (self) -> T ; } impl ConvertPtr < * mut * mut :: std :: os :: raw :: c_void > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut :: std :: os :: raw :: c_void { self as * mut * mut :: std :: os :: raw :: c_void } } impl ConvertPtr < * mut * mut JNIEnv > for * mut * mut JNIEnv { fn convert_ptr (self) -> * mut * mut JNIEnv { self } } let res = unsafe { (* * self . java_vm) . AttachCurrentThread . unwrap () (self . java_vm , (& mut env as * mut * mut JNIEnv) . convert_ptr () , :: std :: ptr :: null_mut () ,) } ; if res != 0 { log :: error ! ("JavaCallback::get_jnienv: AttachCurrentThread failed: {}" , res) ; JniEnvHolder { env : None , callback : self , need_detach : false , } } else { assert ! (! env . is_null ()) ; JniEnvHolder { env : Some (env) , callback : self , need_detach : true , } } } } # [allow (dead_code)] impl Drop for JavaCallback { fn drop (& mut self) { let env = self . get_jni_env () ; if let Some (env) = env . env { assert ! (! env . is_null ()) ; unsafe { (* * env) . DeleteGlobalRef . unwrap () (env , self . this) } ; } else { log :: error ! ("JavaCallback::drop failed, can not get JNIEnv") ; } } } # [allow (dead_code)] fn jni_throw (env : * mut JNIEnv , ex_class : jclass , message : & str) { let c_message = :: std :: ffi :: CString :: new (message) . unwrap () ; let res = unsafe { (* * env) . ThrowNew . unwrap () (env , ex_class , c_message . as_ptr ()) } ; if res != 0 { log :: error ! ("JNI ThrowNew({}) failed for class {:?} failed" , message , ex_class) ; } } # [allow (dead_code)] fn jni_throw_exception (env : * mut JNIEnv , message : & str) { let exception_class = swig_jni_find_class ! (JAVA_LANG_EXCEPTION , "java/lang/Exception") ; jni_throw (env , exception_class , message) } # [allow (dead_code)] fn object_to_jobject < T : SwigForeignClass > (env : * mut JNIEnv , obj : T) -> jobject { let jcls = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null () , "object_to_jobject: AllocObject failed") ; let ret : jlong = < T > :: box_object (obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , ret) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("object_to_jobject: Can not set mNativeObj field: catch exception") ; } } jobj } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Vec < T > => internal_aliases :: JForeignObjectsArray < T > { $ out = vec_of_objects_to_jobject_array (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") => "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn jobject_array_to_vec_of_objects < T : SwigForeignClass + Clone > (env : * mut JNIEnv , arr : internal_aliases :: JForeignObjectsArray < T > ,) -> Vec < T > { let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; let length = unsafe { (* * env) . GetArrayLength . unwrap () (env , arr . inner) } ; let len = < usize as :: std :: convert :: TryFrom < jsize > > :: try_from (length) . expect ("invalid jsize, in jsize => usize conversation") ; let mut result = Vec :: with_capacity (len) ; for i in 0 .. length { let native : & mut T = unsafe { let obj = (* * env) . GetObjectArrayElement . unwrap () (env , arr . inner , i) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Failed to retrieve element {} from this `jobjectArray'" , i) ; } let ptr = (* * env) . GetLongField . unwrap () (env , obj , field_id) ; let native = (jlong_to_pointer (ptr) as * mut T) . as_mut () . unwrap () ; (* * env) . DeleteLocalRef . unwrap () (env , obj) ; native } ; result . push (native . clone ()) ; } result } foreign_typemap ! (($ p : r_type) < T : SwigForeignClass + Clone > Vec < T > <= internal_aliases :: JForeignObjectsArray < T > { $ out = jobject_array_to_vec_of_objects (env , $ p) ; } ; ($ p : f_type , option = "NoNullAnnotations") <= "swig_f_type!(T) []" ; ($ p : f_type , option = "NullAnnotations") <= "@NonNull swig_f_type!(T, NoNullAnnotations) []" ;) ; # [allow (dead_code)] fn vec_of_objects_to_jobject_array < T : SwigForeignClass > (env : * mut JNIEnv , mut arr : Vec < T > ,) -> internal_aliases :: JForeignObjectsArray < T > { let jcls : jclass = < T > :: jni_class () ; assert ! (! jcls . is_null ()) ; let arr_len = < jsize as :: std :: convert :: TryFrom < usize > > :: try_from (arr . len ()) . expect ("invalid usize, in usize => to jsize conversation") ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , arr_len , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; let field_id = < T > :: jni_class_pointer_field () ; assert ! (! field_id . is_null ()) ; for (i , r_obj) in arr . drain (..) . enumerate () { let jobj : jobject = unsafe { (* * env) . AllocObject . unwrap () (env , jcls) } ; assert ! (! jobj . is_null ()) ; let r_obj : jlong = < T > :: box_object (r_obj) ; unsafe { (* * env) . SetLongField . unwrap () (env , jobj , field_id , r_obj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Can not mNativeObj field: catch exception") ; } (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jobj) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jobj) ; } } internal_aliases :: JForeignObjectsArray { inner : obj_arr , _marker : :: std :: marker :: PhantomData , } } # [allow (dead_code)] trait JniInvalidValue { fn jni_invalid_value () -> Self ; } impl < T > JniInvalidValue for * const T { fn jni_invalid_value () -> Self { :: std :: ptr :: null () } } impl < T > JniInvalidValue for * mut T { fn jni_invalid_value () -> Self { :: std :: ptr :: null_mut () } } impl JniInvalidValue for () { fn jni_invalid_value () { } } impl < T : SwigForeignClass > JniInvalidValue for internal_aliases :: JForeignObjectsArray < T > { fn jni_invalid_value () -> Self { Self { inner : :: std :: ptr :: null_mut () , _marker : :: std :: marker :: PhantomData , } } } macro_rules ! impl_jni_jni_invalid_value { ($ ($ type : ty) *) => ($ (impl JniInvalidValue for $ type { fn jni_invalid_value () -> Self { <$ type >:: default () } }) *) } impl_jni_jni_invalid_value ! { jbyte jshort jint jlong jfloat jdouble } foreign_typemap ! (($ p : r_type) < T > Result < T , & str > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) < T > Result < T , String > => swig_i_type ! (T) { $ out = match $ p { Ok (x) => { swig_from_rust_to_i_type ! (T , x , ret) ret } Err (msg) => { jni_throw_exception (env , & msg) ; return < swig_i_type ! (T) >:: jni_invalid_value () ; } } ; } ; ($ p : f_type , unique_prefix = "/*Result*/") => "/*Result*/swig_f_type!(T)" "swig_foreign_from_i_type!(T, $p)" ;) ; foreign_typemap ! (($ p : r_type) bool => jboolean { $ out = if $ p { 1 as jboolean } else { 0 as jboolean } ; } ; ($ p : f_type) => "boolean" ; ($ p : r_type) bool <= jboolean { $ out = $ p != 0 ; } ; ($ p : f_type) <= "boolean" ;) ; foreign_typemap ! (($ p : r_type) SystemTime => jlong { let since_unix_epoch = $ p . duration_since (:: std :: time :: UNIX_EPOCH) . expect ("SystemTime to Unix time conv. error") ; $ out = < i64 as :: std :: convert :: TryFrom < u64 >>:: try_from (since_unix_epoch . as_secs () * 1_000 + u64 :: from (since_unix_epoch . subsec_millis ()) ,) . expect ("SystemTime: milleseconds u64 to i64 convert error") ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Date" "$out = new java.util.Date($p);" ; ($ p : f_type , option = "NullAnnotations") => "@NonNull java.util.Date" "$out = new java.util.Date($p);" ;) ; foreign_typemap ! (($ p : r_type) jbyte => i8 { $ out = $ p ; } ; ($ p : r_type) jbyte <= i8 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u8 => jshort { $ out = jshort :: from ($ p) ; } ;) ; foreign_typemap ! (($ p : r_type) u8 <= jshort { $ out = < u8 as :: std :: convert :: TryFrom < jshort >>:: try_from ($ p) . expect ("invalid jshort, in jshort => u8 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i16 => jshort { $ out = $ p ; } ; ($ p : r_type) i16 <= jshort { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u16 => jint { $ out = jint :: from ($ p) ; } ; ($ p : r_type) u16 <= jint { $ out = < u16 as :: std :: convert :: TryFrom < jint >>:: try_from ($ p) . expect ("invalid jint, in jint => u16 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) jint => i32 { $ out = $ p ; } ; ($ p : r_type) jint <= i32 { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u32 => jlong { $ out = jlong :: from ($ p) ; } ; ($ p : r_type) u32 <= jlong { $ out = < u32 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u32 conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) i64 => jlong { $ out = $ p ; } ; ($ p : r_type) i64 <= jlong { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) u64 => jlong { $ out = < jlong as :: std :: convert :: TryFrom < u64 >>:: try_from ($ p) . expect ("invalid u64, in u64 => jlong conversation") ; } ; ($ p : r_type) u64 <= jlong { $ out = < u64 as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => u64 conversation") ; } ;) ; # [allow (dead_code)] pub fn u64_to_jlong_checked (x : u64) -> jlong { < jlong as :: std :: convert :: TryFrom < u64 > > :: try_from (x) . expect ("invalid u64, in u64 => jlong conversation") } foreign_typemap ! (($ p : r_type) f32 => jfloat { $ out = $ p ; } ; ($ p : r_type) f32 <= jfloat { $ out = $ p ; } ;) ; foreign_typemap ! (($ p : r_type) f64 => jdouble { $ out = $ p ; } ; ($ p : r_type) f64 <= jdouble { $ out = $ p ; } ;) ; impl < 'a > SwigFrom < & 'a str > for jstring { fn swig_from (x : & 'a str , env : * mut JNIEnv) -> Self { let x = :: std :: ffi :: CString :: new (x) . unwrap () ; unsafe { (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } } impl SwigInto < JavaString > for jstring { fn swig_into (self , env : * mut JNIEnv) -> JavaString { JavaString :: new (env , self) } } impl SwigFrom < String > for jstring { fn swig_from (x : String , env : * mut JNIEnv) -> Self { from_std_string_jstring (x , env) } } # [allow (dead_code)] fn from_std_string_jstring (x : String , env : * mut JNIEnv) -> jstring { let x = x . into_bytes () ; unsafe { let x = :: std :: ffi :: CString :: from_vec_unchecked (x) ; (* * env) . NewStringUTF . unwrap () (env , x . as_ptr ()) } } foreign_typemap ! (($ p : r_type) usize <= jlong { $ out = < usize as :: std :: convert :: TryFrom < jlong >>:: try_from ($ p) . expect ("invalid jlong, in jlong => usize conversation") ; } ;) ; foreign_typemap ! (($ p : r_type) & Path <= internal_aliases :: JStringPath { let jstr = JavaString :: new (env , $ p) ; $ out = Path :: new (jstr . to_str ()) ; } ; ($ p : f_type , option = "NoNullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/String" ; ($ p : f_type , option = "NullAnnotations" , unique_prefix = "/*Path*/") <= "/*Path*/@NonNull String" ;) ; # [doc = "swig_ replace"] impl SwigInto < jobjectArray > for Vec < String > { fn swig_into (mut self , env : * mut JNIEnv) -> jobjectArray { let jcls : jclass = swig_jni_find_class ! (JAVA_LANG_STRING , "java/lang/String") ; assert ! (! jcls . is_null ()) ; let obj_arr : jobjectArray = unsafe { (* * env) . NewObjectArray . unwrap () (env , self . len () as jsize , jcls , :: std :: ptr :: null_mut ()) } ; assert ! (! obj_arr . is_null ()) ; for (i , r_str) in self . drain (..) . enumerate () { let jstr : jstring = jstring :: swig_from (r_str , env) ; assert ! (! jstr . is_null ()) ; unsafe { (* * env) . SetObjectArrayElement . unwrap () (env , obj_arr , i as jsize , jstr) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("SetObjectArrayElement({}) failed" , i) ; } (* * env) . DeleteLocalRef . unwrap () (env , jstr) ; } } obj_arr } } macro_rules ! define_array_handling_code { ($ ([jni_arr_type = $ jni_arr_type : ident , rust_arr_wrapper = $ rust_arr_wrapper : ident , jni_get_array_elements = $ jni_get_array_elements : ident , jni_elem_type = $ jni_elem_type : ident , rust_elem_type = $ rust_elem_type : ident , jni_release_array_elements = $ jni_release_array_elements : ident , jni_new_array = $ jni_new_array : ident , jni_set_array_region = $ jni_set_array_region : ident]) ,*) => { $ (# [allow (dead_code)] struct $ rust_arr_wrapper { array : $ jni_arr_type , data : * mut $ jni_elem_type , env : * mut JNIEnv , } # [allow (dead_code)] impl $ rust_arr_wrapper { fn new (env : * mut JNIEnv , array : $ jni_arr_type) -> $ rust_arr_wrapper { assert ! (! array . is_null ()) ; let data = unsafe { (** env) .$ jni_get_array_elements . unwrap () (env , array , :: std :: ptr :: null_mut ()) } ; $ rust_arr_wrapper { array , data , env } } fn to_slice (& self) -> & [$ rust_elem_type] { unsafe { let len : jsize = (** self . env) . GetArrayLength . unwrap () (self . env , self . array) ; assert ! ((len as u64) <= (usize :: max_value () as u64)) ; :: std :: slice :: from_raw_parts (self . data , len as usize) } } fn from_slice_to_raw (arr : & [$ rust_elem_type] , env : * mut JNIEnv) -> $ jni_arr_type { assert ! ((arr . len () as u64) <= (jsize :: max_value () as u64)) ; let jarr : $ jni_arr_type = unsafe { (** env) .$ jni_new_array . unwrap () (env , arr . len () as jsize) } ; assert ! (! jarr . is_null ()) ; unsafe { (** env) .$ jni_set_array_region . unwrap () (env , jarr , 0 , arr . len () as jsize , arr . as_ptr ()) ; if (** env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("{}:{} {} failed" , file ! () , line ! () , stringify ! ($ jni_set_array_region)) ; } } jarr } } # [allow (dead_code)] impl Drop for $ rust_arr_wrapper { fn drop (& mut self) { assert ! (! self . env . is_null ()) ; assert ! (! self . array . is_null ()) ; unsafe { (** self . env) .$ jni_release_array_elements . unwrap () (self . env , self . array , self . data , JNI_ABORT as jint ,) } ; } }) * } } define_array_handling_code ! ([jni_arr_type = jbyteArray , rust_arr_wrapper = JavaByteArray , jni_get_array_elements = GetByteArrayElements , jni_elem_type = jbyte , rust_elem_type = i8 , jni_release_array_elements = ReleaseByteArrayElements , jni_new_array = NewByteArray , jni_set_array_region = SetByteArrayRegion] , [jni_arr_type = jshortArray , rust_arr_wrapper = JavaShortArray , jni_get_array_elements = GetShortArrayElements , jni_elem_type = jshort , rust_elem_type = i16 , jni_release_array_elements = ReleaseShortArrayElements , jni_new_array = NewShortArray , jni_set_array_region = SetShortArrayRegion] , [jni_arr_type = jintArray , rust_arr_wrapper = JavaIntArray , jni_get_array_elements = GetIntArrayElements , jni_elem_type = jint , rust_elem_type = i32 , jni_release_array_elements = ReleaseIntArrayElements , jni_new_array = NewIntArray , jni_set_array_region = SetIntArrayRegion] , [jni_arr_type = jlongArray , rust_arr_wrapper = JavaLongArray , jni_get_array_elements = GetLongArrayElements , jni_elem_type = jlong , rust_elem_type = i64 , jni_release_array_elements = ReleaseLongArrayElements , jni_new_array = NewLongArray , jni_set_array_region = SetLongArrayRegion] , [jni_arr_type = jfloatArray , rust_arr_wrapper = JavaFloatArray , jni_get_array_elements = GetFloatArrayElements , jni_elem_type = jfloat , rust_elem_type = f32 , jni_release_array_elements = ReleaseFloatArrayElements , jni_new_array = NewFloatArray , jni_set_array_region = SetFloatArrayRegion] , [jni_arr_type = jdoubleArray , rust_arr_wrapper = JavaDoubleArray , jni_get_array_elements = GetDoubleArrayElements , jni_elem_type = jdouble , rust_elem_type = f64 , jni_release_array_elements = ReleaseDoubleArrayElements , jni_new_array = NewDoubleArray , jni_set_array_region = SetDoubleArrayRegion]) ; impl < T > SwigDeref for Vec < T > { type Target = [T] ; fn swig_deref (& self) -> & Self :: Target { & * self } } impl SwigDeref for JavaIntArray { type Target = [i32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jintArray > for JavaIntArray { fn swig_from (x : jintArray , env : * mut JNIEnv) -> Self { JavaIntArray :: new (env , x) } } impl < 'a > SwigInto < jintArray > for & 'a [i32] { fn swig_into (self , env : * mut JNIEnv) -> jintArray { JavaIntArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaLongArray { type Target = [i64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jlongArray > for JavaLongArray { fn swig_from (x : jlongArray , env : * mut JNIEnv) -> Self { JavaLongArray :: new (env , x) } } impl < 'a > SwigInto < jlongArray > for & 'a [i64] { fn swig_into (self , env : * mut JNIEnv) -> jlongArray { JavaLongArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaFloatArray { type Target = [f32] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jfloatArray > for JavaFloatArray { fn swig_from (x : jfloatArray , env : * mut JNIEnv) -> Self { JavaFloatArray :: new (env , x) } } impl < 'a > SwigInto < jfloatArray > for & 'a [f32] { fn swig_into (self , env : * mut JNIEnv) -> jfloatArray { JavaFloatArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaDoubleArray { type Target = [f64] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jdoubleArray > for JavaDoubleArray { fn swig_from (x : jdoubleArray , env : * mut JNIEnv) -> Self { JavaDoubleArray :: new (env , x) } } impl < 'a > SwigInto < jdoubleArray > for & 'a [f64] { fn swig_into (self , env : * mut JNIEnv) -> jdoubleArray { JavaDoubleArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaByteArray { type Target = [i8] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jbyteArray > for JavaByteArray { fn swig_from (x : jbyteArray , env : * mut JNIEnv) -> Self { JavaByteArray :: new (env , x) } } impl < 'a > SwigInto < jbyteArray > for & 'a [i8] { fn swig_into (self , env : * mut JNIEnv) -> jbyteArray { JavaByteArray :: from_slice_to_raw (self , env) } } impl SwigDeref for JavaShortArray { type Target = [i16] ; fn swig_deref (& self) -> & Self :: Target { self . to_slice () } } impl SwigFrom < jshortArray > for JavaShortArray { fn swig_from (x : jshortArray , env : * mut JNIEnv) -> Self { JavaShortArray :: new (env , x) } } impl < 'a > SwigInto < jshortArray > for & 'a [i16] { fn swig_into (self , env : * mut JNIEnv) -> jshortArray { JavaShortArray :: from_slice_to_raw (self , env) } } impl SwigDeref for String { type Target = str ; fn swig_deref (& self) -> & str { self } } impl < T > SwigDeref for Arc < Mutex < T > > { type Target = Mutex < T > ; fn swig_deref (& self) -> & Mutex < T > { self } } impl < 'a , T > SwigFrom < & 'a Mutex < T > > for MutexGuard < 'a , T > { fn swig_from (m : & 'a Mutex < T > , _ : * mut JNIEnv) -> MutexGuard < 'a , T > { m . lock () . unwrap () } } impl < 'a , T > SwigDeref for MutexGuard < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for MutexGuard < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T > SwigDeref for Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDeref for & 'a Rc < T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for Ref < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> Ref < 'a , T > { m . borrow () } } impl < 'a , T > SwigFrom < & 'a RefCell < T > > for RefMut < 'a , T > { fn swig_from (m : & 'a RefCell < T > , _ : * mut JNIEnv) -> RefMut < 'a , T > { m . borrow_mut () } } impl < 'a , T > SwigDeref for Ref < 'a , T > { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < 'a , T > SwigDerefMut for RefMut < 'a , T > { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } impl < T : SwigForeignClass > SwigDeref for T { type Target = T ; fn swig_deref (& self) -> & T { self } } impl < T : SwigForeignClass > SwigDerefMut for T { type Target = T ; fn swig_deref_mut (& mut self) -> & mut T { self } } # [cfg (target_pointer_width = "32")] impl SwigFrom < isize > for jint { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jint } } # [cfg (target_pointer_width = "64")] impl SwigFrom < isize > for jlong { fn swig_from (x : isize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "32")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { x as jlong } } # [cfg (target_pointer_width = "64")] impl SwigFrom < usize > for jlong { fn swig_from (x : usize , _ : * mut JNIEnv) -> Self { let x = x as u64 ; u64_to_jlong_checked (x) } } impl < 'a > SwigInto < String > for & 'a str { fn swig_into (self , _ : * mut JNIEnv) -> String { self . into () } } # [allow (dead_code)] fn to_java_util_optional_double (env : * mut JNIEnv , x : Option < f64 > ,) -> internal_aliases :: JOptionalDouble { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_DOUBLE , "java/util/OptionalDouble") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_OF , JAVA_UTIL_OPTIONAL_DOUBLE , "of" , "(D)Ljava/util/OptionalDouble;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_DOUBLE_EMPTY , JAVA_UTIL_OPTIONAL_DOUBLE , "empty" , "()Ljava/util/OptionalDouble;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalDouble.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_double_to_rust (env : * mut JNIEnv , x : internal_aliases :: JDouble) -> Option < f64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_DOUBLE , "java/lang/Double") ; assert ! (! class . is_null ()) ; let double_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_DOUBLE_DOUBLE_VALUE_METHOD , JAVA_LANG_DOUBLE , "doubleValue" , "()D" ,) ; assert ! (! double_value_m . is_null () ,) ; let ret : f64 = unsafe { let ret = (* * env) . CallDoubleMethod . unwrap () (env , x , double_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Double.doubleValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f64 > <= internal_aliases :: JDouble { $ out = from_java_lang_double_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Double" ; (f_type , option = "NullAnnotations") <= "@Nullable Double" ;) ; foreign_typemap ! (($ p : r_type) Option < f64 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalDouble" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalDouble" ;) ; # [allow (dead_code)] fn from_java_lang_float_to_rust (env : * mut JNIEnv , x : internal_aliases :: JFloat) -> Option < f32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_FLOAT , "java/lang/Float") ; assert ! (! class . is_null ()) ; let float_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_FLOAT_FLOAT_VALUE , JAVA_LANG_FLOAT , "floatValue" , "()F") ; assert ! (! float_value_m . is_null ()) ; let ret : f32 = unsafe { let ret = (* * env) . CallFloatMethod . unwrap () (env , x , float_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Float.floatValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < f32 > <= internal_aliases :: JFloat { $ out = from_java_lang_float_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Float" ; (f_type , option = "NullAnnotations") <= "@Nullable Float" ;) ; foreign_typemap ! (($ p : r_type) Option < f32 > => internal_aliases :: JOptionalDouble { $ out = to_java_util_optional_double (env , $ p . map (f64 :: from)) ; } ;) ; # [allow (dead_code)] fn to_java_util_optional_long (env : * mut JNIEnv , x : Option < i64 >) -> internal_aliases :: JOptionalLong { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_LONG , "java/util/OptionalLong") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_OF , JAVA_UTIL_OPTIONAL_LONG , "of" , "(J)Ljava/util/OptionalLong;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_LONG_EMPTY , JAVA_UTIL_OPTIONAL_LONG , "empty" , "()Ljava/util/OptionalLong;" ,) ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalLong.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } # [allow (dead_code)] fn from_java_lang_long_to_rust (env : * mut JNIEnv , x : internal_aliases :: JLong) -> Option < i64 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_LONG , "java/lang/Long") ; assert ! (! class . is_null ()) ; let long_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_LONG_LONG_VALUE , JAVA_LANG_LONG , "longValue" , "()J") ; assert ! (! long_value_m . is_null ()) ; let ret : i64 = unsafe { let ret = (* * env) . CallLongMethod . unwrap () (env , x , long_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Long.longValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i64 > <= internal_aliases :: JLong { $ out = from_java_lang_long_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Long" ; (f_type , option = "NullAnnotations") <= "@Nullable Long" ;) ; foreign_typemap ! (($ p : r_type) Option < i64 > => internal_aliases :: JOptionalLong { $ out = to_java_util_optional_long (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalLong" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalLong" ;) ; # [allow (dead_code)] fn from_java_lang_int_to_rust (env : * mut JNIEnv , x : internal_aliases :: JInteger) -> Option < i32 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_INTEGER , "java/lang/Integer") ; assert ! (! class . is_null ()) ; let int_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_INTEGER_INT_VALUE , JAVA_LANG_INTEGER , "intValue" , "()I") ; assert ! (! int_value_m . is_null () ,) ; let ret : i32 = unsafe { let ret = (* * env) . CallIntMethod . unwrap () (env , x , int_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Integer.intValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_byte_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i8 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_BYTE , "java/lang/Byte") ; assert ! (! class . is_null ()) ; let byte_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_BYTE_BYTE_VALUE , JAVA_LANG_BYTE , "byteValue" , "()B") ; assert ! (! byte_value_m . is_null () ,) ; let ret : i8 = unsafe { let ret = (* * env) . CallByteMethod . unwrap () (env , x , byte_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Byte.byteValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } # [allow (dead_code)] fn from_java_lang_short_to_rust (env : * mut JNIEnv , x : internal_aliases :: JByte) -> Option < i16 > { if x . is_null () { None } else { let x = unsafe { (* * env) . NewLocalRef . unwrap () (env , x) } ; if x . is_null () { None } else { let class : jclass = swig_jni_find_class ! (JAVA_LANG_SHORT , "java/lang/Short") ; assert ! (! class . is_null ()) ; let short_value_m : jmethodID = swig_jni_get_method_id ! (JAVA_LANG_SHORT_SHORT_VALUE , JAVA_LANG_SHORT , "shortValue" , "()S") ; assert ! (! short_value_m . is_null ()) ; let ret : i16 = unsafe { let ret = (* * env) . CallShortMethod . unwrap () (env , x , short_value_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("Short.shortValue failed: catch exception") ; } (* * env) . DeleteLocalRef . unwrap () (env , x) ; ret } ; Some (ret) } } } foreign_typemap ! (($ p : r_type) Option < i32 > <= internal_aliases :: JInteger { $ out = from_java_lang_int_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Integer" ; (f_type , option = "NullAnnotations") <= "@Nullable Integer" ;) ; # [allow (dead_code)] fn to_java_util_optional_int (env : * mut JNIEnv , x : Option < i32 >) -> jobject { let class : jclass = swig_jni_find_class ! (JAVA_UTIL_OPTIONAL_INT , "java/util/OptionalInt") ; assert ! (! class . is_null () ,) ; match x { Some (val) => { let of_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_OF , JAVA_UTIL_OPTIONAL_INT , "of" , "(I)Ljava/util/OptionalInt;") ; assert ! (! of_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , of_m , val) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.of failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } None => { let empty_m : jmethodID = swig_jni_get_static_method_id ! (JAVA_UTIL_OPTIONAL_INT_EMPTY , JAVA_UTIL_OPTIONAL_INT , "empty" , "()Ljava/util/OptionalInt;") ; assert ! (! empty_m . is_null ()) ; let ret = unsafe { let ret = (* * env) . CallStaticObjectMethod . unwrap () (env , class , empty_m) ; if (* * env) . ExceptionCheck . unwrap () (env) != 0 { panic ! ("OptionalInt.empty failed: catch exception") ; } ret } ; assert ! (! ret . is_null ()) ; ret } } } foreign_typemap ! (($ p : r_type) Option < i32 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") => "java.util.OptionalInt" ; (f_type , option = "NullAnnotations") => "@NonNull java.util.OptionalInt" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > <= internal_aliases :: JByte { $ out = from_java_lang_byte_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Byte" ; (f_type , option = "NullAnnotations") <= "@Nullable Byte" ;) ; foreign_typemap ! (($ p : r_type) Option < i8 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > <= internal_aliases :: JShort { $ out = from_java_lang_short_to_rust (env , $ p) ; } ; (f_type , option = "NoNullAnnotations") <= "Short" ; (f_type , option = "NullAnnotations") <= "@Nullable Short" ;) ; foreign_typemap ! (($ p : r_type) Option < i16 > => internal_aliases :: JOptionalInt { $ out = to_java_util_optional_int (env , $ p . map (i32 :: from)) ; } ;) ; foreign_typemap ! (($ p : r_type) < T : SwigForeignClass > Option < T > => jlong { $ out = match $ p { Some (x) => { let ptr = < swig_subst_type ! (T) >:: box_object (x) ; debug_assert_ne ! (0 , ptr) ; ptr } None => 0 , } ; } ; ($ p : f_type , option = "NoNullAnnotations") => "java.util.Optional" r#" [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: method `name` is never used [INFO] [stdout] --> src/typemap/utils.rs:26:8 [INFO] [stdout] | [INFO] [stdout] 25 | pub(crate) trait ForeignTypeInfoT { [INFO] [stdout] | ---------------- method in this trait [INFO] [stdout] 26 | fn name(&self) -> &str; [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: method `output` is never used [INFO] [stdout] --> src/typemap/utils.rs:41:8 [INFO] [stdout] | [INFO] [stdout] 39 | pub(crate) trait ForeignMethodSignature { [INFO] [stdout] | ---------------------- method in this trait [INFO] [stdout] 40 | type FI: ForeignTypeInfoT; [INFO] [stdout] 41 | fn output(&self) -> &dyn ForeignTypeInfoT; [INFO] [stdout] | ^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `span` is never read [INFO] [stdout] --> src/types.rs:126:16 [INFO] [stdout] | [INFO] [stdout] 125 | pub(crate) struct FnDecl { [INFO] [stdout] | ------ field in this struct [INFO] [stdout] 126 | pub(crate) span: Span, [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `FnDecl` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast.rs:721:41 [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec { [INFO] [stdout] | ^^^^^^^^^^^^^^ -------------------- the same lifetime is hidden here [INFO] [stdout] | | [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 721 | pub(crate) fn get_trait_bounds(generic: &syn::Generics) -> GenericTraitBoundVec<'_> { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/ast/subst_map.rs:33:28 [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem] { [INFO] [stdout] | ^^^^^ -------------------- [INFO] [stdout] | | | | [INFO] [stdout] | | | the same lifetime is hidden here [INFO] [stdout] | | the same lifetime is elided here [INFO] [stdout] | the lifetime is elided here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 33 | pub(crate) fn as_slice(&self) -> &[TyParamsSubstItem<'_>] { [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing [INFO] [stdout] --> src/typemap/typemap_macro.rs:193:9 [INFO] [stdout] | [INFO] [stdout] 193 | &self, [INFO] [stdout] | ^^^^^ the lifetime is elided here [INFO] [stdout] ... [INFO] [stdout] 197 | ) -> Option [INFO] [stdout] | ---------------- the same lifetime is hidden here [INFO] [stdout] | [INFO] [stdout] = help: the same lifetime is referred to in inconsistent ways, making the signature confusing [INFO] [stdout] help: use `'_` for type paths [INFO] [stdout] | [INFO] [stdout] 197 | ) -> Option> [INFO] [stdout] | ++++ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 14.30s [INFO] running `Command { std: "docker" "inspect" "c19384dd95f45e554266080c0dfa5c7ee823f347dcd78dfd2617ed2f4351af76", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "c19384dd95f45e554266080c0dfa5c7ee823f347dcd78dfd2617ed2f4351af76", kill_on_drop: false }` [INFO] [stdout] c19384dd95f45e554266080c0dfa5c7ee823f347dcd78dfd2617ed2f4351af76