decode_field removed

Author: milyin

zenoh-flat/src/jni_converter.rs

@@ -54,7 +54,7 @@ impl Default for StructBuilder {
         Self {
             source_module: syn::parse_str("crate").unwrap(),
             zresult: syn::parse_str("ZResult").unwrap(),
-            types: JniTypeBinding::new(),
+            types: JniTypeBinding::new().with_builtins(),
         }
     }
 }
@@ -180,53 +180,42 @@ impl JniStructConverter {
             let kotlin_fname = snake_to_camel(&fname);
             let err_prefix = format!("{struct_name}.{kotlin_fname}: {{}}");
 
-            let kind = self.classify_struct_field(&field.ty);
-            match kind {
-                StructFieldKind::Bool => {
-                    field_preludes.push(quote! {
-                        let #fname_ident = env.get_field(obj, #kotlin_fname, "Z")
-                            .and_then(|v| v.z())
-                            .map_err(|err| zerror!(#err_prefix, err))?;
-                    });
-                    field_init.push(quote! { #fname_ident });
-                    kotlin_field_lines.push(format!("    val {}: Boolean,", kotlin_fname));
-                }
-                StructFieldKind::I64 => {
-                    field_preludes.push(quote! {
-                        let #fname_ident = env.get_field(obj, #kotlin_fname, "J")
-                            .and_then(|v| v.j())
-                            .map_err(|err| zerror!(#err_prefix, err))?;
-                    });
-                    field_init.push(quote! { #fname_ident });
-                    kotlin_field_lines.push(format!("    val {}: Long,", kotlin_fname));
-                }
-                StructFieldKind::F64 => {
-                    field_preludes.push(quote! {
-                        let #fname_ident = env.get_field(obj, #kotlin_fname, "D")
-                            .and_then(|v| v.d())
-                            .map_err(|err| zerror!(#err_prefix, err))?;
-                    });
-                    field_init.push(quote! { #fname_ident });
-                    kotlin_field_lines.push(format!("    val {}: Double,", kotlin_fname));
-                }
-                StructFieldKind::Enum(decoder) => {
-                    let raw_ident = format_ident!("__{}_raw", fname_ident);
-                    field_preludes.push(quote! {
-                        let #raw_ident = env.get_field(obj, #kotlin_fname, "I")
-                            .and_then(|v| v.i())
-                            .map_err(|err| zerror!(#err_prefix, err))?;
-                        let #fname_ident = #decoder(#raw_ident)?;
-                    });
-                    field_init.push(quote! { #fname_ident });
-                    kotlin_field_lines.push(format!("    val {}: Int,", kotlin_fname));
-                }
-                StructFieldKind::Unsupported => panic!(
+            let binding = self.lookup_struct_field_binding(&field.ty).unwrap_or_else(|| {
+                panic!(
                     "unsupported field type `{}` for `{}.{}` at {loc}",
                     field.ty.to_token_stream(),
                     struct_name,
                     fname
-                ),
-            }
+                )
+            });
+            let (jni_sig, jvalue_method) =
+                jni_primitive_signature(binding.jni_type()).unwrap_or_else(|| {
+                    panic!(
+                        "field `{}.{}` at {loc}: type `{}` has non-primitive JNI wire form `{}`",
+                        struct_name,
+                        fname,
+                        field.ty.to_token_stream(),
+                        binding.jni_type().to_token_stream()
+                    )
+                });
+            let raw_ident = format_ident!("__{}_raw", fname_ident);
+            let jni_type = binding.jni_type();
+            let decode_expr = binding
+                .decode()
+                .expect("struct-field binding must have a decode")
+                .call(&raw_ident);
+            field_preludes.push(quote! {
+                let #raw_ident: #jni_type = env.get_field(obj, #kotlin_fname, #jni_sig)
+                    .and_then(|v| v.#jvalue_method())
+                    .map_err(|err| zerror!(#err_prefix, err))? as _;
+                let #fname_ident = #decode_expr;
+            });
+            field_init.push(quote! { #fname_ident });
+            kotlin_field_lines.push(format!(
+                "    val {}: {},",
+                kotlin_fname,
+                binding.kotlin_type()
+            ));
         }
 
         let tokens = quote! {
@@ -261,28 +250,15 @@ impl JniStructConverter {
         syn::parse2(tokens).expect("generated struct decoder must parse")
     }
 
-    /// Classify a `#[prebindgen]` struct field's type for JNI round-tripping.
-    fn classify_struct_field(&self, ty: &syn::Type) -> StructFieldKind {
-        let syn::Type::Path(tp) = ty else {
-            return StructFieldKind::Unsupported;
-        };
-        let Some(last) = tp.path.segments.last() else {
-            return StructFieldKind::Unsupported;
-        };
+    /// Look up a `#[prebindgen]` struct field's type in the registry. Fields
+    /// must use the type's bare path-tail name (e.g. `bool`, `i64`,
+    /// `CongestionControl`) and must resolve to a registered binding whose
+    /// JNI wire form is one of the primitive `j*` types.
+    fn lookup_struct_field_binding(&self, ty: &syn::Type) -> Option<&TypeBinding> {
+        let syn::Type::Path(tp) = ty else { return None };
+        let last = tp.path.segments.last()?;
         let name = last.ident.to_string();
-        match name.as_str() {
-            "bool" => StructFieldKind::Bool,
-            "i64" => StructFieldKind::I64,
-            "f64" => StructFieldKind::F64,
-            _ => {
-                if let Some(binding) = self.cfg.types.types.get(&name) {
-                    if let Some(p) = binding.enum_field_decoder_path() {
-                        return StructFieldKind::Enum(p.clone());
-                    }
-                }
-                StructFieldKind::Unsupported
-            }
-        }
+        self.cfg.types.types.get(&name)
     }
 }
 
@@ -800,13 +776,26 @@ impl JniMethodsConverter {
 // Internal helpers
 // =====================================================================
 
-/// Field-type classification for `#[prebindgen]` struct fields.
-enum StructFieldKind {
-    Bool,
-    I64,
-    F64,
-    Enum(syn::Path),
-    Unsupported,
+/// Map a primitive JNI wire type (`jni::sys::j*`) to the JVM field
+/// signature character and the matching `JValue` accessor method.
+/// Returns `None` for non-primitive (object-shaped) wire types.
+fn jni_primitive_signature(jni_type: &syn::Type) -> Option<(&'static str, syn::Ident)> {
+    let syn::Type::Path(tp) = jni_type else {
+        return None;
+    };
+    let last = tp.path.segments.last()?;
+    let (sig, accessor) = match last.ident.to_string().as_str() {
+        "jboolean" => ("Z", "z"),
+        "jbyte" => ("B", "b"),
+        "jchar" => ("C", "c"),
+        "jshort" => ("S", "s"),
+        "jint" => ("I", "i"),
+        "jlong" => ("J", "j"),
+        "jfloat" => ("F", "f"),
+        "jdouble" => ("D", "d"),
+        _ => return None,
+    };
+    Some((sig, format_ident!("{}", accessor)))
 }
 
 fn is_unit(ty: &syn::Type) -> bool {

zenoh-flat/src/jni_type_binding.rs

@@ -11,8 +11,6 @@
 //! * `jni_type`    — the on-the-wire JNI type emitted in the wrapper signature
 //! * `decode`      — JNI value → Rust value (param-direction rows)
 //! * `encode` + `default_expr` — Rust value → JNI value (return-direction rows)
-//! * `enum_field_decoder` — only for enum-shaped rows, used by struct-field
-//!   classification
 //!
 //! Wrapper types (`&T`, `Vec<T>`, `Option<T>`, `ZResult<T>`) are **not**
 //! decomposed by the classifier — each must have its own explicit row. The
@@ -108,10 +106,6 @@ pub struct TypeBinding {
     /// Default JNI value emitted on the throw-return path. Required when
     /// `encode` is set.
     pub(crate) default_expr: Option<syn::Expr>,
-    /// Decoder path for Java-enum-shaped types (`fn(jint) -> ZResult<T>`).
-    /// Used by struct-field classification to detect enum fields and emit
-    /// `env.get_field(..., "I")` + decoder call.
-    pub(crate) enum_field_decoder: Option<syn::Path>,
 }
 
 impl TypeBinding {
@@ -129,7 +123,6 @@ impl TypeBinding {
             decode: Some(decode),
             encode: None,
             default_expr: None,
-            enum_field_decoder: None,
         }
     }
 
@@ -151,20 +144,9 @@ impl TypeBinding {
                 syn::parse_str(default_expr.as_ref())
                     .expect("invalid TypeBinding::returns default_expr"),
             ),
-            enum_field_decoder: None,
         }
     }
 
-    /// Mark this binding as a Java-enum-shaped type. Used by struct-field
-    /// classification to emit `env.get_field(..., "I")` + `<path>(raw)?`.
-    pub fn enum_field_decoder(mut self, path: impl AsRef<str>) -> Self {
-        self.enum_field_decoder = Some(
-            syn::parse_str(path.as_ref())
-                .expect("invalid TypeBinding::enum_field_decoder path"),
-        );
-        self
-    }
-
     /// Convenience: opaque borrow `&T` — JNI side passes raw `*const T`,
     /// decoded via `<owned_object>::from_raw`. Because the row's key starts
     /// with `&`, the wrapped fn receives `&name` automatically.
@@ -228,7 +210,6 @@ impl TypeBinding {
             })),
             encode: None,
             default_expr: None,
-            enum_field_decoder: None,
         }
     }
 
@@ -252,9 +233,6 @@ impl TypeBinding {
     pub(crate) fn default_expr(&self) -> Option<&syn::Expr> {
         self.default_expr.as_ref()
     }
-    pub(crate) fn enum_field_decoder_path(&self) -> Option<&syn::Path> {
-        self.enum_field_decoder.as_ref()
-    }
     /// `&T` row — wrapped fn receives `&name`.
     pub(crate) fn is_borrow(&self) -> bool {
         self.rust_type.starts_with('&')
@@ -306,8 +284,8 @@ impl JniTypeBinding {
     }
 
     /// Pre-register built-in language types whose JNI form is fully described
-    /// without any project-specific decoder path: `bool` (inline `x != 0`)
-    /// and `Duration` (inline `Duration::from_millis(x as u64)`).
+    /// without any project-specific decoder path: `bool`, `i64`, `f64`, and
+    /// `Duration`.
     pub fn with_builtins(mut self) -> Self {
         let bool_row = TypeBinding::param(
             "bool",
@@ -317,6 +295,22 @@ impl JniTypeBinding {
         );
         self.types.insert(bool_row.rust_type.clone(), bool_row);
 
+        let i64_row = TypeBinding::param(
+            "i64",
+            "Long",
+            "jni::sys::jlong",
+            InlineFn::new(|input| quote! { #input }),
+        );
+        self.types.insert(i64_row.rust_type.clone(), i64_row);
+
+        let f64_row = TypeBinding::param(
+            "f64",
+            "Double",
+            "jni::sys::jdouble",
+            InlineFn::new(|input| quote! { #input }),
+        );
+        self.types.insert(f64_row.rust_type.clone(), f64_row);
+
         let duration_row = TypeBinding::param(
             "Duration",
             "Long",

zenoh-jni/build.rs

@@ -56,37 +56,37 @@ fn shared_bindings() -> JniTypeBinding {
             "Int",
             "jni::sys::jint",
             InlineFn::pure("crate::utils::decode_congestion_control"),
-        ).enum_field_decoder("crate::utils::decode_congestion_control"))
+        ))
         .type_binding(TypeBinding::param(
             "Priority",
             "Int",
             "jni::sys::jint",
             InlineFn::pure("crate::utils::decode_priority"),
-        ).enum_field_decoder("crate::utils::decode_priority"))
+        ))
         .type_binding(TypeBinding::param(
             "Reliability",
             "Int",
             "jni::sys::jint",
             InlineFn::pure("crate::utils::decode_reliability"),
-        ).enum_field_decoder("crate::utils::decode_reliability"))
+        ))
         .type_binding(TypeBinding::param(
             "QueryTarget",
             "Int",
             "jni::sys::jint",
             InlineFn::pure("crate::utils::decode_query_target"),
-        ).enum_field_decoder("crate::utils::decode_query_target"))
+        ))
         .type_binding(TypeBinding::param(
             "ConsolidationMode",
             "Int",
             "jni::sys::jint",
             InlineFn::pure("crate::utils::decode_consolidation"),
-        ).enum_field_decoder("crate::utils::decode_consolidation"))
+        ))
         .type_binding(TypeBinding::param(
             "ReplyKeyExpr",
             "Int",
             "jni::sys::jint",
             InlineFn::pure("crate::utils::decode_reply_key_expr"),
-        ).enum_field_decoder("crate::utils::decode_reply_key_expr"))
+        ))
         // KeyExpr by-value: JNI side passes `Arc::into_raw(Arc::new(KeyExpr))`
         // as a raw pointer; the wrapper reconstructs the Arc, clones the inner
         // KeyExpr, and drops the Arc at end of scope. The full path is required