separate fn dispatch

Author: milyin

prebindgen-ext/src/core/prebindgen_ext.rs

@@ -157,6 +157,36 @@ pub trait PrebindgenExt {
         None
     }
 
+    /// Build the wrapper converter for an
+    /// `impl Fn(args...) + Send + Sync + 'static` parameter, given the
+    /// already-extracted arg types in declaration order. The resolver
+    /// calls this only after [`Self::on_input_type_rank_0`] /
+    /// [`Self::on_input_type_rank_1`] / [`Self::on_input_type_rank_2`] /
+    /// [`Self::on_input_type_rank_3`] (for the appropriate arity) has
+    /// returned `None`, so wrappers that need custom callback dispatch
+    /// can intercept earlier and skip this path.
+    ///
+    /// `args` are the rust-side argument types as they appear in the
+    /// source signature. Note that callback args flow inverse to the
+    /// callback parameter itself: the callback parameter is *input*,
+    /// but its args are produced by the rust side and consumed by the
+    /// foreign side, so they are *output* direction for converter
+    /// resolution. The framework handles this direction-flip at
+    /// registration time (`register_type_inner` in `core::registry`),
+    /// so implementations of this method should look up
+    /// already-registered *output* converters for each arg type.
+    ///
+    /// Default: `None`. Backends that support `impl Fn` callbacks
+    /// (e.g. [`crate::jni::JniExt`]) override this.
+    fn dispatch_fn_input(
+        &self,
+        args: &[syn::Type],
+        registry: &Registry,
+    ) -> Option<ConverterImpl> {
+        let _ = (args, registry);
+        None
+    }
+
     // ── Output direction (rust → wire) ─────────────────────────────
 
     /// Whole-type output converter.

prebindgen-ext/src/core/registry.rs

@@ -466,9 +466,6 @@ impl Registry {
 
 /// Number of leaves in a type's substitutable-position tree.
 pub fn compute_rank(ty: &syn::Type) -> usize {
-    if let Some(args) = extract_fn_trait_args(ty) {
-        return args.iter().map(|t| std::cmp::max(1, compute_rank(t))).sum();
-    }
     let positions = immediate_subtype_positions(ty);
     if positions.is_empty() {
         return 0;

prebindgen-ext/src/core/resolve.rs

@@ -171,6 +171,21 @@ fn try_resolve_entry<E: PrebindgenExt>(
             Direction::Input => ext.on_input_type_rank_0(key_ty, registry),
             Direction::Output => ext.on_output_type_rank_0(key_ty, registry),
         };
+        // Zero-arg `impl Fn() + Send + Sync + 'static` fallback: after
+        // the implementer's own rank-0 handler returns None, route the
+        // empty arg-list to `dispatch_fn_input`. Non-empty Fn arities
+        // are handled in the rank-N loop below.
+        let res = res.or_else(|| {
+            if dir != Direction::Input {
+                return None;
+            }
+            let args = crate::core::registry::extract_fn_trait_args(key_ty)?;
+            if args.is_empty() {
+                ext.dispatch_fn_input(&args, registry)
+            } else {
+                None
+            }
+        });
         return res.map(|c| TypeEntry {
             destination: c.destination,
             function: c.function,
@@ -198,6 +213,25 @@ fn try_resolve_entry<E: PrebindgenExt>(
             }
             _ => unreachable!("rank N is bounded to 0..=3 by MAX_RANK"),
         };
+        // Fallback for `impl Fn(args...) + Send + Sync + 'static`: after
+        // the implementer's own rank-N handler returns None, route the
+        // canonical `impl Fn(_, _, …)` pattern (every arg slot is a
+        // wildcard) to `dispatch_fn_input`. Non-canonical patterns like
+        // `impl Fn(Option<_>, _)` are left for user rank handlers — only
+        // the all-wildcards shape gets the framework default.
+        let result = result.or_else(|| {
+            if dir != Direction::Input {
+                return None;
+            }
+            let pat_args = crate::core::registry::extract_fn_trait_args(&pattern)?;
+            if pat_args.len() != subs.len() {
+                return None;
+            }
+            if !pat_args.iter().all(|t| matches!(t, syn::Type::Infer(_))) {
+                return None;
+            }
+            ext.dispatch_fn_input(subs.as_slice(), registry)
+        });
         // Last-step fallback for `impl Into<_> + Send + 'static`:
         // after the implementer's own rank-1 handler returns None,
         // assemble the source list (identity arm first when `target`
@@ -685,6 +719,44 @@ mod tests {
         assert_eq!(s[0].1, vec!["KeyExpr < 'static >"]);
     }
 
+    /// Codifies the canonical-shape detection used by the rank-N
+    /// `dispatch_fn_input` fallback in [`try_resolve_entry`]. For
+    /// `impl Fn(Option<Sample>)` at rank 1, `enumerate_wildcard_subs`
+    /// emits both `impl Fn(_)` (canonical — every Fn arg slot is a
+    /// wildcard, fallback should fire) and `impl Fn(Option<_>)`
+    /// (non-canonical — fallback must skip so a user rank-1 handler
+    /// can claim it). The fallback distinguishes them by checking that
+    /// every element of `extract_fn_trait_args(&pattern)` is a
+    /// `Type::Infer`; this test pins that invariant.
+    #[test]
+    fn impl_fn_canonical_pattern_is_distinguishable_from_nested() {
+        use crate::core::registry::extract_fn_trait_args;
+        let t = ty("impl Fn(Option<Sample>) + Send + Sync + 'static");
+        let v = enumerate_wildcard_subs(&t, 1);
+        // Two rank-1 variants: deepest-first (Option<_> over Sample),
+        // then the canonical Fn(_) over Option<Sample>.
+        assert_eq!(v.len(), 2);
+        let mut canonical_count = 0;
+        let mut nested_count = 0;
+        for (pattern, _subs) in &v {
+            let args = extract_fn_trait_args(pattern).unwrap();
+            let all_infer = args.iter().all(|a| matches!(a, syn::Type::Infer(_)));
+            if all_infer {
+                canonical_count += 1;
+            } else {
+                nested_count += 1;
+            }
+        }
+        assert_eq!(
+            canonical_count, 1,
+            "exactly one canonical `impl Fn(_)` pattern is expected"
+        );
+        assert_eq!(
+            nested_count, 1,
+            "exactly one nested `impl Fn(Option<_>)` pattern is expected"
+        );
+    }
+
     #[test]
     fn impl_into_recognized_only_with_send_static() {
         use crate::core::registry::extract_into_trait_arg;

prebindgen-ext/src/jni/jni_ext.rs

@@ -441,19 +441,6 @@ impl PrebindgenExt for JniExt {
         ty: &syn::Type,
         registry: &Registry,
     ) -> Option<ConverterImpl> {
-        if let Some(args) = extract_fn_trait_args(ty) {
-            if args.is_empty() {
-                let arg_tys: [syn::Type; 0] = [];
-                let outer_ty = build_fn_type(&arg_tys);
-                let (wire, body) = callback_input(self, &arg_tys, registry)?;
-                let niches = default_niches_for_wire(&wire);
-                return Some(ConverterImpl {
-                    function: self.input_wrapper(&outer_ty, &wire, &body),
-                    destination: wire,
-                    niches,
-                });
-            }
-        }
         if let Some((wire, body)) = primitive_input(ty) {
             let niches = default_niches_for_wire(&wire);
             return Some(ConverterImpl {
@@ -512,19 +499,6 @@ impl PrebindgenExt for JniExt {
                 niches,
             });
         }
-        if let Some(args) = extract_fn_trait_args(pat) {
-            if args.len() == 1 {
-                let arg_tys = std::slice::from_ref(t1);
-                let outer_ty = build_fn_type(arg_tys);
-                let (wire, body) = callback_input(self, arg_tys, registry)?;
-                let niches = default_niches_for_wire(&wire);
-                return Some(ConverterImpl {
-                    function: self.input_wrapper(&outer_ty, &wire, &body),
-                    destination: wire,
-                    niches,
-                });
-            }
-        }
         None
     }
 
@@ -537,26 +511,29 @@ impl PrebindgenExt for JniExt {
         self.emit_into_dispatcher(target, sources, registry)
     }
 
+    fn dispatch_fn_input(
+        &self,
+        args: &[syn::Type],
+        registry: &Registry,
+    ) -> Option<ConverterImpl> {
+        let outer_ty = build_fn_type(args);
+        let (wire, body) = callback_input(self, args, registry)?;
+        let niches = default_niches_for_wire(&wire);
+        Some(ConverterImpl {
+            function: self.input_wrapper(&outer_ty, &wire, &body),
+            destination: wire,
+            niches,
+        })
+    }
+
     fn on_input_type_rank_2(
         &self,
         pat: &syn::Type,
         t1: &syn::Type,
         t2: &syn::Type,
         registry: &Registry,
     ) -> Option<ConverterImpl> {
-        if let Some(args) = extract_fn_trait_args(pat) {
-            if args.len() == 2 {
-                let arg_tys = [t1.clone(), t2.clone()];
-                let outer_ty = build_fn_type(&arg_tys);
-                let (wire, body) = callback_input(self, &arg_tys, registry)?;
-                let niches = default_niches_for_wire(&wire);
-                return Some(ConverterImpl {
-                    function: self.input_wrapper(&outer_ty, &wire, &body),
-                    destination: wire,
-                    niches,
-                });
-            }
-        }
+        let _ = (pat, t1, t2, registry);
         None
     }
 
@@ -568,19 +545,7 @@ impl PrebindgenExt for JniExt {
         t3: &syn::Type,
         registry: &Registry,
     ) -> Option<ConverterImpl> {
-        if let Some(args) = extract_fn_trait_args(pat) {
-            if args.len() == 3 {
-                let arg_tys = [t1.clone(), t2.clone(), t3.clone()];
-                let outer_ty = build_fn_type(&arg_tys);
-                let (wire, body) = callback_input(self, &arg_tys, registry)?;
-                let niches = default_niches_for_wire(&wire);
-                return Some(ConverterImpl {
-                    function: self.input_wrapper(&outer_ty, &wire, &body),
-                    destination: wire,
-                    niches,
-                });
-            }
-        }
+        let _ = (pat, t1, t2, t3, registry);
         None
     }
 

zenoh-jni/build.rs

@@ -243,6 +243,10 @@ impl PrebindgenExt for ZenohJniExt {
         self.base.dispatch_into_input(target, sources, registry)
     }
 
+    fn dispatch_fn_input(&self, args: &[syn::Type], registry: &Registry) -> Option<ConverterImpl> {
+        self.base.dispatch_fn_input(args, registry)
+    }
+
     // ── Output rank-0 — zenoh-specific arms first ──
 
     fn on_output_type_rank_0(&self, ty: &syn::Type, registry: &Registry) -> Option<ConverterImpl> {