ArgDecode enum removed

Author: milyin

zenoh-flat/src/jni_converter.rs

@@ -48,45 +48,6 @@ pub use crate::jni_type_binding::TypeBinding;
 // Decode / encode strategies
 // =====================================================================
 
-/// Strategy for converting a JNI parameter into a Rust value.
-#[derive(Clone)]
-pub enum ArgDecode {
-    /// `let <name> = <path>(&mut env, &<input>)?;` — for decoders that need
-    /// mutable access to the JNI environment (e.g. `JNIEnv::get_string`).
-    EnvRefMut(syn::Path),
-    /// `let <name> = <path>(&env, &<input>)?;` — for decoders that only
-    /// need shared access to the JNI environment (e.g. byte-array readers
-    /// whose `JNIEnv` methods take `&self`).
-    EnvRef(syn::Path),
-    /// `let <name> = <path>(<input>)?;` — pure conversion (e.g. enum decoders).
-    Pure(syn::Path),
-    /// `let <name> = <expr>;` — inline transformation built from the input
-    /// ident. Used for trivial conversions like `bool` (`x != 0`) or
-    /// `Duration` (`Duration::from_millis(x as u64)`).
-    Inline(InlineFn),
-}
-
-impl ArgDecode {
-    /// `ArgDecode::Pure` from a path string (parsed lazily).
-    pub fn pure(path: impl AsRef<str>) -> Self {
-        ArgDecode::Pure(syn::parse_str(path.as_ref()).expect("invalid ArgDecode::pure path"))
-    }
-
-    /// `ArgDecode::EnvRefMut` from a path string.
-    pub fn env_ref_mut(path: impl AsRef<str>) -> Self {
-        ArgDecode::EnvRefMut(
-            syn::parse_str(path.as_ref()).expect("invalid ArgDecode::env_ref_mut path"),
-        )
-    }
-
-    /// `ArgDecode::EnvRef` from a path string.
-    pub fn env_ref(path: impl AsRef<str>) -> Self {
-        ArgDecode::EnvRef(
-            syn::parse_str(path.as_ref()).expect("invalid ArgDecode::env_ref path"),
-        )
-    }
-}
-
 impl ReturnEncode {
     /// `ReturnEncode::Wrapper` from a path string.
     pub fn wrapper(path: impl AsRef<str>) -> Self {
@@ -97,6 +58,11 @@ impl ReturnEncode {
 }
 
 /// Clonable closure that produces a TokenStream from the JNI input ident.
+///
+/// This is the single decoding mechanism used by [`JniForm`]. Common decoder
+/// shapes are exposed via [`InlineFn::pure`], [`InlineFn::env_ref`], and
+/// [`InlineFn::env_ref_mut`], which capture a decoder path as a `String`
+/// (since `syn::Path` is not `Send`) and re-parse it inside the closure.
 #[derive(Clone)]
 pub struct InlineFn(Arc<dyn Fn(&syn::Ident) -> TokenStream + Send + Sync>);
 
@@ -108,6 +74,35 @@ impl InlineFn {
         InlineFn(Arc::new(f))
     }
 
+    /// `<path>(<input>)?` — pure conversion (e.g. enum decoders).
+    pub fn pure(path: impl AsRef<str>) -> Self {
+        let s = path.as_ref().to_string();
+        InlineFn::new(move |input| {
+            let p: syn::Path = syn::parse_str(&s).expect("invalid InlineFn::pure path");
+            quote! { #p(#input)? }
+        })
+    }
+
+    /// `<path>(&env, &<input>)?` — decoder needing shared access to the JNI env
+    /// (e.g. byte-array readers whose `JNIEnv` methods take `&self`).
+    pub fn env_ref(path: impl AsRef<str>) -> Self {
+        let s = path.as_ref().to_string();
+        InlineFn::new(move |input| {
+            let p: syn::Path = syn::parse_str(&s).expect("invalid InlineFn::env_ref path");
+            quote! { #p(&env, &#input)? }
+        })
+    }
+
+    /// `<path>(&mut env, &<input>)?` — decoder needing mutable access to the
+    /// JNI env (e.g. `JNIEnv::get_string`).
+    pub fn env_ref_mut(path: impl AsRef<str>) -> Self {
+        let s = path.as_ref().to_string();
+        InlineFn::new(move |input| {
+            let p: syn::Path = syn::parse_str(&s).expect("invalid InlineFn::env_ref_mut path");
+            quote! { #p(&mut env, &#input)? }
+        })
+    }
+
     fn call(&self, ident: &syn::Ident) -> TokenStream {
         (self.0)(ident)
     }
@@ -131,14 +126,14 @@ pub struct JniForm {
     /// decoder produces an owner (e.g. `OwnedObject`) but the wrapped
     /// function expects a shared reference.
     call_with_ref: bool,
-    decode: ArgDecode,
+    decode: InlineFn,
 }
 
 impl JniForm {
     pub fn new(
         jni_type: impl AsRef<str>,
         kotlin_jni_type: impl Into<String>,
-        decode: ArgDecode,
+        decode: InlineFn,
     ) -> Self {
         Self {
             jni_type: syn::parse_str(jni_type.as_ref()).expect("invalid JniForm jni_type"),
@@ -426,14 +421,13 @@ impl JniStructConverter {
             }
         };
 
-        let decoder_path: syn::Path = syn::parse_str(&format!("decode_{struct_name}"))
-            .expect("generated decoder ident must parse as path");
+        let decoder_path = format!("decode_{struct_name}");
         let mut binding = TypeBinding::new(struct_name.clone());
         binding.kotlin_type = Some(struct_name.clone());
         binding.consume = Some(JniForm::new(
             "jni::objects::JObject",
             "JObject",
-            ArgDecode::EnvRefMut(decoder_path),
+            InlineFn::env_ref_mut(&decoder_path),
         ));
         self.cfg.types.types.insert(struct_name.clone(), binding);
 
@@ -461,13 +455,9 @@ impl JniStructConverter {
             "i64" => StructFieldKind::I64,
             "f64" => StructFieldKind::F64,
             _ => {
-                // Enum decoders are stored as a `Pure` ArgDecode on the
-                // type's binding's `consume` form.
                 if let Some(binding) = self.cfg.types.types.get(&name) {
-                    if let Some(form) = binding.consume.as_ref() {
-                        if let ArgDecode::Pure(p) = &form.decode {
-                            return StructFieldKind::Enum(p.clone());
-                        }
+                    if let Some(p) = binding.enum_decoder.as_ref() {
+                        return StructFieldKind::Enum(p.clone());
                     }
                 }
                 StructFieldKind::Unsupported
@@ -1012,11 +1002,11 @@ impl JniMethodsConverter {
                     kotlin_jni_type: "Long".to_string(),
                     pointer_param: true,
                     call_with_ref: true,
-                    decode: ArgDecode::Inline(InlineFn::new(move |input| {
+                    decode: InlineFn::new(move |input| {
                         let owned: syn::Path =
                             syn::parse_str(&owned_str).expect("owned_object must be a valid path");
                         quote! { #owned::from_raw(#input) }
-                    })),
+                    }),
                 };
                 ArgKind::Borrow {
                     form: opaque_form,
@@ -1205,21 +1195,8 @@ impl JniMethodsConverter {
         };
         jni_params.push(quote! { #pat: #jt });
 
-        match &form.decode {
-            ArgDecode::EnvRefMut(path) => {
-                prelude.push(quote! { let #name = #path(&mut env, &#pat)?; });
-            }
-            ArgDecode::EnvRef(path) => {
-                prelude.push(quote! { let #name = #path(&env, &#pat)?; });
-            }
-            ArgDecode::Pure(path) => {
-                prelude.push(quote! { let #name = #path(#pat)?; });
-            }
-            ArgDecode::Inline(f) => {
-                let expr = f.call(&pat);
-                prelude.push(quote! { let #name = #expr; });
-            }
-        }
+        let expr = form.decode.call(&pat);
+        prelude.push(quote! { let #name = #expr; });
 
         if form.call_with_ref {
             call_args.push(quote! { &#name });
@@ -1238,13 +1215,8 @@ impl JniMethodsConverter {
         }
     }
 
-    fn decode_expr(&self, decode: &ArgDecode, input: &syn::Ident) -> TokenStream {
-        match decode {
-            ArgDecode::EnvRefMut(path) => quote! { #path(&mut env, &#input)? },
-            ArgDecode::EnvRef(path) => quote! { #path(&env, &#input)? },
-            ArgDecode::Pure(path) => quote! { #path(#input)? },
-            ArgDecode::Inline(f) => f.call(input),
-        }
+    fn decode_expr(&self, decode: &InlineFn, input: &syn::Ident) -> TokenStream {
+        decode.call(input)
     }
 
     /// Resolve the Kotlin parameter type for a JniForm. For object-typed

zenoh-flat/src/jni_type_binding.rs

@@ -8,16 +8,19 @@
 //! [`crate::jni_converter::JniMethodsConverter`] reads it).
 //!
 //! ```ignore
-//! use zenoh_flat::jni_converter::{ArgDecode, JniForm, TypeBinding};
+//! use zenoh_flat::jni_converter::{InlineFn, JniForm, TypeBinding};
 //! use zenoh_flat::jni_type_binding::JniTypeBinding;
+//! use quote::quote;
 //!
 //! let common = JniTypeBinding::new()
 //!     .type_binding(
 //!         TypeBinding::new("KeyExpr").consume(
 //!             JniForm::new(
 //!                 "*const zenoh::key_expr::KeyExpr<'static>",
 //!                 "Long",
-//!                 ArgDecode::ConsumeArc,
+//!                 InlineFn::new(|input| {
+//!                     quote! { (*std::sync::Arc::from_raw(#input)).clone() }
+//!                 }),
 //!             )
 //!             .pointer_param(true),
 //!         ),
@@ -28,7 +31,7 @@ use std::collections::HashMap;
 
 use quote::{quote, ToTokens};
 
-use crate::jni_converter::{ArgDecode, InlineFn, JniForm, ReturnForm};
+use crate::jni_converter::{InlineFn, JniForm, ReturnForm};
 
 /// Per-type description of how a Rust type is represented across the JNI
 /// boundary. A type may declare up to four forms:
@@ -52,6 +55,11 @@ pub struct TypeBinding {
     pub(crate) borrow: Option<JniForm>,
     pub(crate) returns: Option<ReturnForm>,
     pub(crate) returns_vec: Option<ReturnForm>,
+    /// Decoder path for Java-enum-shaped types (`fn(jint) -> ZResult<T>`).
+    /// Set when the type's JNI representation is an `Int` mapped through a
+    /// pure decoder. Used by struct-field classification to detect enum
+    /// fields and emit `env.get_field(..., "I")` + decoder call.
+    pub(crate) enum_decoder: Option<syn::Path>,
 }
 
 impl TypeBinding {
@@ -77,6 +85,7 @@ impl TypeBinding {
             borrow: None,
             returns: None,
             returns_vec: None,
+            enum_decoder: None,
         }
     }
 
@@ -85,6 +94,16 @@ impl TypeBinding {
         self
     }
 
+    /// Mark this binding as a Java-enum-shaped type and record the
+    /// `fn(jint) -> ZResult<T>` decoder path used for both top-level
+    /// argument decoding and struct-field decoding.
+    pub fn enum_decoder(mut self, path: impl AsRef<str>) -> Self {
+        self.enum_decoder = Some(
+            syn::parse_str(path.as_ref()).expect("invalid TypeBinding::enum_decoder path"),
+        );
+        self
+    }
+
     pub fn consume(mut self, form: JniForm) -> Self {
         self.consume = Some(form);
         self
@@ -157,7 +176,7 @@ impl JniTypeBinding {
             TypeBinding::new("bool").consume(JniForm::new(
                 "jni::sys::jboolean",
                 "Boolean",
-                ArgDecode::Inline(InlineFn::new(|input| quote! { #input != 0 })),
+                InlineFn::new(|input| quote! { #input != 0 }),
             )),
         );
         // Duration — jlong, inline `Duration::from_millis(x as u64)`.
@@ -166,9 +185,9 @@ impl JniTypeBinding {
             TypeBinding::new("Duration").consume(JniForm::new(
                 "jni::sys::jlong",
                 "Long",
-                ArgDecode::Inline(InlineFn::new(|input| {
+                InlineFn::new(|input| {
                     quote! { std::time::Duration::from_millis(#input as u64) }
-                })),
+                }),
             )),
         );
         self

zenoh-jni/build.rs

@@ -1,20 +1,26 @@
 use itertools::Itertools;
 use quote::quote;
 use zenoh_flat::jni_converter::{
-    ArgDecode, InlineFn, JniForm, JniMethodsConverter, JniStructConverter, ReturnEncode,
-    ReturnForm, TypeBinding,
+    InlineFn, JniForm, JniMethodsConverter, JniStructConverter, ReturnEncode, ReturnForm,
+    TypeBinding,
 };
 use zenoh_flat::jni_type_binding::JniTypeBinding;
 
 fn enum_binding(name: &str, decoder: &str) -> TypeBinding {
-    TypeBinding::new(name).consume(JniForm::new("jni::sys::jint", "Int", ArgDecode::pure(decoder)))
+    TypeBinding::new(name)
+        .enum_decoder(decoder)
+        .consume(JniForm::new(
+            "jni::sys::jint",
+            "Int",
+            InlineFn::pure(decoder),
+        ))
 }
 
 fn jobject_consume(name: &str, decoder: &str, kotlin: &str) -> TypeBinding {
     TypeBinding::new(name).kotlin(kotlin).consume(JniForm::new(
         "jni::objects::JObject",
         "JObject",
-        ArgDecode::env_ref_mut(decoder),
+        InlineFn::env_ref_mut(decoder),
     ))
 }
 
@@ -28,7 +34,7 @@ fn shared_bindings() -> JniTypeBinding {
             TypeBinding::new("String").consume(JniForm::new(
                 "jni::objects::JString",
                 "String",
-                ArgDecode::env_ref_mut("crate::utils::decode_string"),
+                InlineFn::env_ref_mut("crate::utils::decode_string"),
             )),
         )
         // `Vec<u8>` is keyed under the synthetic name "VecU8" — the
@@ -38,7 +44,7 @@ fn shared_bindings() -> JniTypeBinding {
             TypeBinding::new("VecU8").consume(JniForm::new(
                 "jni::objects::JByteArray",
                 "ByteArray",
-                ArgDecode::env_ref("crate::utils::decode_byte_array"),
+                InlineFn::env_ref("crate::utils::decode_byte_array"),
             )),
         )
         .type_binding(jobject_consume(
@@ -88,9 +94,9 @@ fn shared_bindings() -> JniTypeBinding {
                 JniForm::new(
                     "*const zenoh::key_expr::KeyExpr<'static>",
                     "Long",
-                    ArgDecode::Inline(InlineFn::new(|input| {
+                    InlineFn::new(|input| {
                         quote! { (*std::sync::Arc::from_raw(#input)).clone() }
-                    })),
+                    }),
                 )
                 .pointer_param(true),
             ),