Skip to main content

miniextendr_macros/
miniextendr_trait.rs

1//! # Trait Support for `#[miniextendr]`
2//!
3//! This module handles `#[miniextendr]` applied to trait definitions,
4//! generating the ABI infrastructure for cross-package trait dispatch.
5//!
6//! ## Overview
7//!
8//! When `#[miniextendr]` is applied to a trait, it generates:
9//!
10//! 1. **Type tag constant** (`TAG_<TraitName>`) - 128-bit identifier for runtime type checking
11//! 2. **Vtable struct** (`<TraitName>VTable`) - Function pointer table for method dispatch
12//! 3. **View struct** (`<TraitName>View`) - Runtime wrapper combining data pointer and vtable
13//! 4. **Method shims** - `extern "C"` functions that convert SEXP arguments and call methods
14//! 5. **Vtable builder** - `__<trait>_build_vtable::<T>()` for impl blocks
15//!
16//! ## Usage
17//!
18//! ```ignore
19//! #[miniextendr]
20//! pub trait Counter {
21//!     fn value(&self) -> i32;
22//!     fn increment(&mut self);
23//!     fn add(&mut self, n: i32);
24//! }
25//! ```
26//!
27//! Generates (conceptually):
28//!
29//! ```text
30//! // Original trait (passed through)
31//! pub trait Counter {
32//!     fn value(&self) -> i32;
33//!     fn increment(&mut self);
34//!     fn add(&mut self, n: i32);
35//! }
36//!
37//! // Type tag for runtime identification
38//! pub const TAG_Counter: mx_tag = mx_tag::new(0x..., 0x...);
39//!
40//! // Vtable with one entry per method
41//! #[repr(C)]
42//! pub struct CounterVTable {
43//!     pub value: mx_meth,
44//!     pub increment: mx_meth,
45//!     pub add: mx_meth,
46//! }
47//!
48//! // View over the data and vtable pointers; roots its R receiver
49//! pub struct CounterView {
50//!     __mx_view: miniextendr_api::trait_abi::TraitViewData<CounterVTable>,
51//! }
52//!
53//! // Shim for each method
54//! unsafe extern "C" fn __Counter_value_shim<T: Counter>(
55//!     data: *mut c_void, argc: i32, argv: *const SEXP
56//! ) -> SEXP {
57//!     // 1. Check arity
58//!     // 2. Cast data to &T
59//!     // 3. Call method
60//!     // 4. Convert result to SEXP
61//!     // 5. Catch panics
62//! }
63//!
64//! // Builder to create vtable for a concrete type
65//! pub const fn __Counter_build_vtable<T: Counter>() -> CounterVTable {
66//!     CounterVTable {
67//!         value: __Counter_value_shim::<T>,
68//!         increment: __Counter_increment_shim::<T>,
69//!         add: __Counter_add_shim::<T>,
70//!     }
71//! }
72//! ```
73//!
74//! ## Supported Method Signatures
75//!
76//! Methods must follow these constraints:
77//!
78//! - **Receiver**: `&self`, `&mut self`, `self: ExternalPtrRef<'_, Self>` or
79//!   `self: ExternalPtrMut<'_, Self>` for instance methods, or none for static methods.
80//!   Borrowed-owner receivers require `Self: TypedExternal`; their emitted Rust
81//!   signatures are associated functions accepting the handle by value.
82//! - **Arguments**: Types that implement `TryFromSexp`
83//! - **Return**: Types that implement `IntoR`, or `()`
84//! - **No generics**: Methods cannot have generic type parameters
85//! - **No async**: Async methods are not supported
86//! - **Static methods**: Methods without a receiver are allowed and resolved at compile time
87//!   (they don't go through the vtable)
88//!
89//! ## Default Methods
90//!
91//! Default method implementations are supported. The vtable builder will
92//! use the default implementation if the concrete type doesn't override it.
93//!
94//! ```ignore
95//! #[miniextendr]
96//! pub trait Counter {
97//!     fn value(&self) -> i32;
98//!
99//!     // Default implementation - included in vtable
100//!     fn is_zero(&self) -> bool {
101//!         self.value() == 0
102//!     }
103//! }
104//! ```
105//!
106//! ## Error Handling
107//!
108//! A method shim runs inside `with_r_unwind_protect_shim`, which turns a Rust
109//! panic into a tagged condition SEXP; the View re-panics with it in the
110//! caller's guard. These panic:
111//!
112//! - **Arity mismatch**: "expected N arguments, got M"
113//! - **Aliased native borrows**: two arguments (or two elements of one) that
114//!   borrow the same R vector, at least one mutably, checked before any
115//!   argument is converted
116//! - **Type conversion failure**: the converter's error message
117//! - **The method itself**
118//!
119//! ## GC Protection
120//!
121//! A View method converts each argument to a fresh SEXP, and the next
122//! conversion allocates, so it protects every converted argument in a
123//! `ProtectScope` as soon as it exists and keeps it protected across the
124//! vtable call. The returned SEXP is protected across the tagged-error check
125//! and its conversion back to Rust.
126//!
127//! ## Thread Safety
128//!
129//! All generated shims are **main-thread only**. They do not route through
130//! `with_r_thread` because R invokes `.Call` on the main thread.
131
132use proc_macro2::TokenStream;
133use syn::ItemTrait;
134
135/// Expand `#[miniextendr]` applied to a trait definition.
136///
137/// # Arguments
138///
139/// * `attr` - Attribute arguments (currently unused, reserved for future options)
140/// * `item` - The trait definition token stream
141///
142/// # Returns
143///
144/// Expanded token stream containing:
145/// - Original trait definition
146/// - Type tag constant
147/// - Vtable struct
148/// - View struct
149/// - Method shims
150/// - Vtable builder function
151///
152/// # Errors
153///
154/// Returns a compile error if:
155/// - Methods have unsupported signatures
156/// - Methods are async
157pub fn expand_trait(
158    _attr: proc_macro::TokenStream,
159    item: proc_macro::TokenStream,
160) -> proc_macro::TokenStream {
161    let trait_item = match ::syn::parse::<ItemTrait>(item) {
    ::syn::__private::Ok(data) => data,
    ::syn::__private::Err(err) => {
        return ::syn::__private::TokenStream::from(err.to_compile_error());
    }
}syn::parse_macro_input!(item as ItemTrait);
162
163    // Validate trait constraints
164    if let Err(e) = validate_trait(&trait_item) {
165        return e.into_compile_error().into();
166    }
167
168    // Generate the expanded code
169    let expanded = generate_trait_abi(&trait_item);
170
171    expanded.into()
172}
173
174/// Validate that the trait meets requirements for ABI generation.
175///
176/// # Constraints
177///
178/// - Instance methods use shared/mutable references or explicit borrowed-owner receivers
179/// - Methods cannot be async
180/// - Methods cannot have generic parameters
181/// - Generic type parameters on the trait itself are allowed
182fn validate_trait(trait_item: &ItemTrait) -> syn::Result<()> {
183    let trait_name = &trait_item.ident;
184
185    // Validate each method
186    for item in &trait_item.items {
187        if let syn::TraitItem::Fn(method) = item {
188            validate_method(method, trait_name)?;
189        }
190    }
191
192    Ok(())
193}
194
195/// Validate a single trait method for ABI compatibility.
196///
197/// Rejects async methods, methods with generic type parameters, and methods
198/// that take `self` by value (only `&self` and `&mut self` are allowed).
199/// Static methods (no receiver) are permitted.
200fn validate_method(method: &syn::TraitItemFn, trait_name: &syn::Ident) -> syn::Result<()> {
201    let method_name = &method.sig.ident;
202
203    // Check for async
204    if method.sig.asyncness.is_some() {
205        return Err(syn::Error::new_spanned(
206            method.sig.asyncness,
207            ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("#[miniextendr] trait `{0}::{1}` cannot be async",
                trait_name, method_name))
    })format!(
208                "#[miniextendr] trait `{}::{}` cannot be async",
209                trait_name, method_name
210            ),
211        ));
212    }
213
214    // Check for type/const generics on method.
215    // Lifetime params are allowed (erased at codegen); type/const params would require
216    // monomorphization and are incompatible with the vtable-shim codegen path.
217    {
218        let has_type_or_const = method
219            .sig
220            .generics
221            .params
222            .iter()
223            .any(|p| #[allow(non_exhaustive_omitted_patterns)] match p {
    syn::GenericParam::Type(_) | syn::GenericParam::Const(_) => true,
    _ => false,
}matches!(p, syn::GenericParam::Type(_) | syn::GenericParam::Const(_)));
224        if has_type_or_const {
225            return Err(syn::Error::new_spanned(
226                &method.sig.generics,
227                ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("#[miniextendr] trait method `{0}::{1}` cannot have generic type or const parameters",
                trait_name, method_name))
    })format!(
228                    "#[miniextendr] trait method `{}::{}` cannot have generic type or const parameters",
229                    trait_name, method_name
230                ),
231            ));
232        }
233    }
234
235    // Instance receivers borrow Self directly or carry an explicit borrowed owner.
236    // Static methods are allowed but won't be included in the vtable
237    // (they're resolved at compile time via <Type as Trait>::method())
238    let receiver = method.sig.inputs.first();
239    if let Some(syn::FnArg::Receiver(r)) = receiver {
240        // Accept either:
241        // - `&self` / `&mut self` (r.reference is Some)
242        // - `self: &Self` / `self: &mut Self` (r.colon_token is Some with reference type)
243        let is_ref = if r.reference.is_some() {
244            true
245        } else if r.colon_token.is_some() {
246            // Check if the type is a reference type (&Self or &mut Self)
247            #[allow(non_exhaustive_omitted_patterns)] match r.ty.as_ref() {
    syn::Type::Reference(_) => true,
    _ => false,
}matches!(r.ty.as_ref(), syn::Type::Reference(_))
248        } else {
249            false
250        };
251
252        if !is_ref && crate::trait_receiver::owner_receiver(&method.sig).is_none() {
253            return Err(syn::Error::new_spanned(
254                r,
255                ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("#[miniextendr] trait method `{0}::{1}` receiver must be `&self` or `&mut self`, not `self` by value",
                trait_name, method_name))
    })format!(
256                    "#[miniextendr] trait method `{}::{}` receiver must be `&self` or `&mut self`, not `self` by value",
257                    trait_name, method_name
258                ),
259            ));
260        }
261    }
262    // If receiver is None or FnArg::Typed (no self), it's a static method - allowed
263
264    // The unforced dots (#1892) cannot cross the vtable, nor can the RNG
265    // guard (#2002).
266    crate::miniextendr_fn::refuse_lazy_dots_in_trait_method(&method.sig.inputs)?;
267    crate::miniextendr_fn::refuse_rng_guard_in_trait_method(&method.sig.inputs)?;
268
269    Ok(())
270}
271
272/// Generate the ABI infrastructure for a trait.
273///
274/// This is the main code generation function that produces:
275/// - Type tag constant
276/// - Vtable struct
277/// - View struct (skipped for generic traits)
278/// - Method shims (with trait type params threaded through)
279/// - Vtable builder (with trait type params threaded through)
280fn generate_trait_abi(trait_item: &ItemTrait) -> TokenStream {
281    let trait_name = &trait_item.ident;
282    let vis = &trait_item.vis;
283
284    // Generate names for generated items
285    let tag_name = crate::naming::trait_tag_ident(trait_name);
286    let vtable_name = match ::quote::__private::IdentFragmentAdapter(&trait_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}VTable", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}quote::format_ident!("{}VTable", trait_name);
287    let view_name = match ::quote::__private::IdentFragmentAdapter(&trait_name) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}View", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}quote::format_ident!("{}View", trait_name);
288    let build_vtable_fn = crate::naming::trait_vtable_builder_ident(trait_name);
289
290    // Collect trait-level generic type parameters
291    let trait_type_params: Vec<&syn::GenericParam> = trait_item.generics.params.iter().collect();
292    let trait_param_idents: Vec<&syn::Ident> = trait_type_params
293        .iter()
294        .filter_map(|p| {
295            if let syn::GenericParam::Type(tp) = p {
296                Some(&tp.ident)
297            } else {
298                None
299            }
300        })
301        .collect();
302    let has_generics = !trait_item.generics.params.is_empty();
303
304    // Collect associated types
305    let assoc_types: Vec<&syn::Ident> = trait_item
306        .items
307        .iter()
308        .filter_map(|item| {
309            if let syn::TraitItem::Type(t) = item {
310                Some(&t.ident)
311            } else {
312                None
313            }
314        })
315        .collect();
316
317    // Collect trait where clause
318    let trait_where_clause = &trait_item.generics.where_clause;
319
320    // Collect method information
321    // Filter to only include instance methods (with &self or &mut self) that aren't skipped
322    let methods: Vec<_> = {
323        let mut collected = Vec::new();
324        for item in &trait_item.items {
325            if let syn::TraitItem::Fn(method) = item {
326                let info = match extract_method_info(method) {
327                    Ok(info) => info,
328                    Err(e) => return e.into_compile_error(),
329                };
330                if info.has_self && !info.skip {
331                    collected.push(info);
332                }
333            }
334        }
335        collected
336    }
337    .into_iter()
338    .collect();
339
340    // Query must reject incompatible declarations before a View reads a slot.
341    // Package/module paths must not enter the tag: independently compiled
342    // declarations of the same interface need to agree across DLLs.
343    let tag_path = trait_abi_tag_path(trait_name, &methods);
344
345    // Generate vtable fields
346    let vtable_fields: Vec<_> = methods
347        .iter()
348        .map(|m| {
349            let name = &m.name;
350            let abi = if m.owner_receiver.is_some() {
351                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "mx_owner_meth");
    _s
}quote::quote!(::miniextendr_api::abi::mx_owner_meth)
352            } else {
353                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "mx_meth");
    _s
}quote::quote!(::miniextendr_api::abi::mx_meth)
354            };
355            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&abi, &mut _s);
    _s
}quote::quote! { pub #name: #abi }
356        })
357        .collect();
358
359    // Compute extra bounds needed for shims
360    let extra_bounds =
361        compute_extra_bounds(&methods, trait_name, &assoc_types, &trait_param_idents);
362
363    // Build trait bound for __ImplT
364    let impl_t = ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("__ImplT"))
            }), ::quote::__private::Option::None)quote::format_ident!("__ImplT");
365    let trait_bound = if trait_param_idents.is_empty() {
366        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    _s
}quote::quote! { #trait_name }
367    } else {
368        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    ::quote::__private::push_lt(&mut _s);
    {
        use ::quote::__private::ext::*;
        let mut _first = true;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut trait_param_idents, i) =
            trait_param_idents.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let trait_param_idents =
                match trait_param_idents.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            if !_first { ::quote::__private::push_comma(&mut _s); }
            _first = false;
            ::quote::ToTokens::to_tokens(&trait_param_idents, &mut _s);
        }
    }
    ::quote::__private::push_gt(&mut _s);
    _s
}quote::quote! { #trait_name<#(#trait_param_idents),*> }
369    };
370
371    // Build combined where clause
372    let all_where_predicates = build_where_predicates(trait_where_clause, &extra_bounds);
373    let where_clause = if all_where_predicates.is_empty() {
374        ::quote::__private::TokenStream::new();quote::quote! {}
375    } else {
376        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "where");
    {
        use ::quote::__private::ext::*;
        let mut _first = true;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut all_where_predicates, i) =
            all_where_predicates.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let all_where_predicates =
                match all_where_predicates.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            if !_first { ::quote::__private::push_comma(&mut _s); }
            _first = false;
            ::quote::ToTokens::to_tokens(&all_where_predicates, &mut _s);
        }
    }
    _s
}quote::quote! { where #(#all_where_predicates),* }
377    };
378
379    // Declaration-side builders select the same associated callbacks as impls.
380    let vtable_inits: Vec<_> = methods
381        .iter()
382        .map(|m| {
383            let name = &m.name;
384            let shim_name = crate::naming::trait_method_shim_ident(trait_name, name);
385            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
    ::quote::__private::push_ident(&mut _s, "as");
    ::quote::ToTokens::to_tokens(&trait_bound, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&shim_name, &mut _s);
    _s
}quote::quote! {
386                #name: <#impl_t as #trait_bound>::#shim_name
387            }
388        })
389        .collect();
390
391    // Generate method wrappers for the View struct
392    // Skip entirely for generic traits (type-erased view can't know type params)
393    let view_methods: Vec<_> = if has_generics {
394        ::alloc::vec::Vec::new()vec![]
395    } else {
396        methods.iter().filter_map(generate_view_method).collect()
397    };
398
399    // Strip #[miniextendr(...)] attrs from trait items before emitting
400    let mut clean_trait = trait_item.clone();
401    for item in &mut clean_trait.items {
402        if let syn::TraitItem::Fn(method) = item {
403            method
404                .attrs
405                .retain(|attr| !attr.path().is_ident("miniextendr"));
406            crate::trait_receiver::rewrite(&mut method.sig, method.default.as_mut());
407        }
408    }
409
410    // Non-generic shims are hidden trait methods, so an impl reaches them
411    // through any path to the trait. A generic trait's impls generate their
412    // own concrete shims from their signatures.
413    if !has_generics {
414        clean_trait.items.extend(methods.iter().map(|m| {
415            syn::TraitItem::Fn(associated_method_shim(generate_method_shim(
416                trait_name,
417                m,
418                &extra_bounds,
419                &trait_param_idents,
420                &trait_type_params,
421                trait_where_clause,
422            )))
423        }));
424    }
425
426    let trait_name_str = trait_name.to_string();
427    let source_loc_doc = crate::source_location_doc(trait_name.span());
428
429    let impl_bounds = &extra_bounds.impl_bounds;
430
431    // View struct and its impls (skipped for generic traits)
432    let view_tokens = if has_generics {
433        ::quote::__private::TokenStream::new();quote::quote! {}
434    } else {
435        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Runtime view for objects implementing `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&source_loc_doc, &mut _s);
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Generated from source file `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "file");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Keeps the receiver alive for method dispatch. Use `try_from_sexp`\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" to create a view with its own root for the R external pointer.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Construction, use and drop belong on R\'s main thread.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s,
                        "non_camel_case_types");
                    _s
                });
            _s
        });
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "struct");
    ::quote::ToTokens::to_tokens(&view_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "__mx_view");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "trait_abi");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "TraitViewData");
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&vtable_name, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "TraitView");
    ::quote::__private::push_ident(&mut _s, "for");
    ::quote::ToTokens::to_tokens(&view_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_ident(&mut _s, "TAG");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "abi");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "mx_tag");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&tag_name, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "unsafe");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_raw_parts");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "data");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_star(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "mut");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "os");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "raw");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "c_void");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vtable");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_star(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "const");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "std");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "os");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "raw");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "c_void");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "owner");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "option");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "Option");
                    ::quote::__private::push_lt(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    ::quote::__private::push_gt(&mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "Self");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "__mx_view");
                            ::quote::__private::push_colon(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "unsafe");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "trait_abi");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "TraitViewData");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "new");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::push_ident(&mut _s, "data");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "vtable");
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "owner");
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_comma(&mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "impl");
    ::quote::ToTokens::to_tokens(&view_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Try to create a view from an R SEXP.\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Returns `Some(Self)` if the object implements this trait,\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" `None` otherwise.\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\" # Safety\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" - `sexp` must be a valid R external pointer (EXTPTRSXP)\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" - The object must stay live through construction; the view then roots it\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" - A call that conflicts with one still running on the same object\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\"   raises the `miniextendr_borrow_conflict` error\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" - Construction, use and drop must all run on R\'s main thread\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "unsafe");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "try_from_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "sexp");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "option");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Option");
            ::quote::__private::push_lt(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_lt(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "Self");
                            ::quote::__private::push_ident(&mut _s, "as");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "TraitView");
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "sexp");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Try to create a view, panicking with error message on failure.\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\" # Safety\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "r\"\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "doc");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "r\" Same as `try_from_sexp`.\"");
                    _s
                });
            ::quote::__private::push_pound(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "inline");
                    _s
                });
            ::quote::__private::push_ident(&mut _s, "pub");
            ::quote::__private::push_ident(&mut _s, "unsafe");
            ::quote::__private::push_ident(&mut _s, "fn");
            ::quote::__private::push_ident(&mut _s, "from_sexp");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "sexp");
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "SEXP");
                    _s
                });
            ::quote::__private::push_rarrow(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Self");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unsafe");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "Self");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "try_from_sexp");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_ident(&mut _s, "sexp");
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "expect");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "core");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "concat");
                            ::quote::__private::push_bang(&mut _s);
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s,
                                        "\"Object does not implement \"");
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&trait_name_str, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::parse(&mut _s, "\" trait\"");
                                    _s
                                });
                            _s
                        });
                    _s
                });
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut view_methods, i) = view_methods.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let view_methods =
                        match view_methods.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&view_methods, &mut _s);
                }
            }
            _s
        });
    _s
}quote::quote! {
436            #[doc = ::core::concat!(
437                "Runtime view for objects implementing `",
438                ::core::stringify!(#trait_name),
439                "`."
440            )]
441            #[doc = #source_loc_doc]
442            #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
443            ///
444            /// Keeps the receiver alive for method dispatch. Use `try_from_sexp`
445            /// to create a view with its own root for the R external pointer.
446            /// Construction, use and drop belong on R's main thread.
447            #[allow(non_camel_case_types)]
448            #vis struct #view_name {
449                __mx_view: ::miniextendr_api::trait_abi::TraitViewData<#vtable_name>,
450            }
451
452            // TraitView implementation
453            impl ::miniextendr_api::TraitView for #view_name {
454                const TAG: ::miniextendr_api::abi::mx_tag = #tag_name;
455
456                #[inline]
457                unsafe fn from_raw_parts(
458                    data: *mut ::std::os::raw::c_void,
459                    vtable: *const ::std::os::raw::c_void,
460                    owner: ::core::option::Option<::miniextendr_api::SEXP>,
461                ) -> Self {
462                    Self {
463                        __mx_view: unsafe {
464                            ::miniextendr_api::trait_abi::TraitViewData::new(data, vtable, owner)
465                        },
466                    }
467                }
468            }
469
470            // Method wrappers on View
471            impl #view_name {
472                /// Try to create a view from an R SEXP.
473                ///
474                /// Returns `Some(Self)` if the object implements this trait,
475                /// `None` otherwise.
476                ///
477                /// # Safety
478                ///
479                /// - `sexp` must be a valid R external pointer (EXTPTRSXP)
480                /// - The object must stay live through construction; the view then roots it
481                /// - A call that conflicts with one still running on the same object
482                ///   raises the `miniextendr_borrow_conflict` error
483                /// - Construction, use and drop must all run on R's main thread
484                #[inline]
485                pub unsafe fn try_from_sexp(sexp: ::miniextendr_api::SEXP) -> ::core::option::Option<Self> {
486                    unsafe { <Self as ::miniextendr_api::TraitView>::try_from_sexp(sexp) }
487                }
488
489                /// Try to create a view, panicking with error message on failure.
490                ///
491                /// # Safety
492                ///
493                /// Same as `try_from_sexp`.
494                #[inline]
495                pub unsafe fn from_sexp(sexp: ::miniextendr_api::SEXP) -> Self {
496                    unsafe { Self::try_from_sexp(sexp) }
497                        .expect(::core::concat!("Object does not implement ", #trait_name_str, " trait"))
498                }
499
500                #(#view_methods)*
501            }
502        }
503    };
504
505    // For generic traits (with type params like <T>), skip shim and builder generation.
506    // These are generated at the impl site with concrete types to avoid recursive trait
507    // resolution overflow (e.g., `Vec<T>: TryFromSexp` triggers infinite recursion through
508    // `impl<T> TryFromSexp for Vec<Vec<T>>`).
509    let shim_and_builder = if has_generics {
510        ::quote::__private::TokenStream::new();quote::quote! {}
511    } else {
512        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Build a vtable for a concrete type implementing `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&source_loc_doc, &mut _s);
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Generated from source file `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "file");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "non_snake_case");
                    _s
                });
            _s
        });
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::ToTokens::to_tokens(&build_vtable_fn, &mut _s);
    ::quote::__private::push_lt(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut trait_type_params, i) = trait_type_params.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let trait_type_params =
                match trait_type_params.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&trait_type_params, &mut _s);
            ::quote::__private::push_comma(&mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&trait_bound, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut impl_bounds, i) = impl_bounds.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let impl_bounds =
                match impl_bounds.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::__private::push_add(&mut _s);
            ::quote::ToTokens::to_tokens(&impl_bounds, &mut _s);
        }
    }
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::ToTokens::to_tokens(&vtable_name, &mut _s);
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&vtable_name, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut vtable_inits, i) = vtable_inits.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let vtable_inits =
                                match vtable_inits.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&vtable_inits, &mut _s);
                        }
                    }
                    _s
                });
            _s
        });
    _s
}quote::quote! {
513            #[doc = ::core::concat!(
514                "Build a vtable for a concrete type implementing `",
515                ::core::stringify!(#trait_name),
516                "`."
517            )]
518            #[doc = #source_loc_doc]
519            #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
520            #[allow(non_snake_case)]
521            #vis const fn #build_vtable_fn<#(#trait_type_params,)* #impl_t: #trait_bound #(+ #impl_bounds)*>() -> #vtable_name
522            #where_clause
523            {
524                #vtable_name {
525                    #(#vtable_inits),*
526                }
527            }
528        }
529    };
530
531    // All impls receive the declaration's R metadata, including generic traits
532    // and traits with associated types. Signatures for empty impls still use
533    // the established non-generic TPIE path.
534    let mut method_metadata = Vec::new();
535    let mut tpie_method_metadata = Vec::new();
536    for item in &trait_item.items {
537        if let syn::TraitItem::Fn(method) = item {
538            let info = match extract_method_info(method) {
539                Ok(info) => info,
540                Err(e) => return e.into_compile_error(),
541            };
542            let name = &method.sig.ident;
543            let r_name_attr = info
544                .r_name
545                .as_ref()
546                .map(|name| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "miniextendr");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "r_name");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::ToTokens::to_tokens(&name, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote::quote!(#[miniextendr(r_name = #name)]));
547            let skip_attr = info.skip.then(|| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "miniextendr");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "skip");
                    _s
                });
            _s
        });
    _s
}quote::quote!(#[miniextendr(skip)]));
548            // Copied signatures name every parameter as the declaration's
549            // metadata does (`arg<i>` for a pattern), since the generated
550            // wrappers pass each argument by name.
551            let mut sig = method.sig.clone();
552            for (arg, name) in sig
553                .inputs
554                .iter_mut()
555                .filter_map(|arg| match arg {
556                    syn::FnArg::Typed(arg) => Some(arg),
557                    syn::FnArg::Receiver(_) => None,
558                })
559                .zip(&info.param_names)
560            {
561                *arg.pat = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::ToTokens::to_tokens(&name, &mut _s);
        _s
    })syn::parse_quote!(#name);
562            }
563            // Every method carries the declaration's docs: an impl's wrapper
564            // documents an inherited default, a method an empty impl
565            // registers, and a written method without docs of its own with
566            // them.
567            let docs: Vec<_> = method
568                .attrs
569                .iter()
570                .filter(|attr| attr.path().is_ident("doc"))
571                .collect();
572            // Keep default signatures, but never copy their bodies into an
573            // implementation. Generated wrappers call the trait's own default,
574            // so an impl that omits a default still gets its R wrapper, generic
575            // trait or not. Required methods carry names only, preserving
576            // impl-local types.
577            if method.default.is_some() {
578                method_metadata.push({
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut docs, i) = docs.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let docs =
                match docs.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&docs, &mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&r_name_attr, &mut _s);
    ::quote::ToTokens::to_tokens(&skip_attr, &mut _s);
    ::quote::ToTokens::to_tokens(&sig, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        ::quote::__private::TokenStream::new());
    _s
}quote::quote! {
579                    #(#docs)* #r_name_attr #skip_attr #sig {}
580                });
581            } else {
582                let params = &info.param_names;
583                method_metadata.push({
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut docs, i) = docs.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let docs =
                match docs.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&docs, &mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&r_name_attr, &mut _s);
    ::quote::ToTokens::to_tokens(&skip_attr, &mut _s);
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut params, i) = params.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let params =
                        match params.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&params, &mut _s);
                    ::quote::__private::push_colon(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                }
            }
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! {
584                    #(#docs)* #r_name_attr #skip_attr fn #name(#(#params: ()),*);
585                });
586            }
587            if !has_generics && assoc_types.is_empty() && !info.skip {
588                let r_name = info
589                    .r_name
590                    .as_deref()
591                    .map(crate::naming::name_ident)
592                    .unwrap_or_else(|| name.clone());
593                tpie_method_metadata.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "method");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "r_name");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&r_name, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut docs, i) = docs.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let docs =
                        match docs.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::ToTokens::to_tokens(&docs, &mut _s);
                }
            }
            ::quote::ToTokens::to_tokens(&sig, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote::quote! {
594                    method { r_name = #r_name; #(#docs)* #sig; }
595                });
596            }
597        }
598    }
599    // The impl receives the exact declaration layout and fingerprint, never
600    // a guessed path to companion items. No caller-scope types occur here.
601    let abi_metadata = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "abi");
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    ::quote::ToTokens::to_tokens(&has_generics, &mut _s);
    ::quote::ToTokens::to_tokens(&tag_path, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut vtable_fields, i) = vtable_fields.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let vtable_fields =
                        match vtable_fields.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&vtable_fields, &mut _s);
                }
            }
            _s
        });
    _s
}quote::quote! {
602        abi #trait_name #has_generics #tag_path { #(#vtable_fields),* }
603    };
604    let empty_impl_arm = if !has_generics && assoc_types.is_empty() {
605        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "concrete_type");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ty");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "trait_path");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "path");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "class_system");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ident");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "no_rd");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "tt");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "internal");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "tt");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "noexport");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "tt");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::parse(&mut _s, "$");
            ::quote::__private::push_ident(&mut _s, "no_preconditions");
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "tt");
            _s
        });
    ::quote::__private::push_fat_arrow(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_trait_impl_expand");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "concrete_type");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "concrete_type");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "trait_path");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "trait_path");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "class_system");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "class_system");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "no_rd");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "no_rd");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "internal");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "internal");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "noexport");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "noexport");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "no_preconditions");
                    ::quote::__private::push_eq(&mut _s);
                    ::quote::__private::parse(&mut _s, "$");
                    ::quote::__private::push_ident(&mut _s, "no_preconditions");
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&abi_metadata, &mut _s);
                    {
                        use ::quote::__private::ext::*;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut tpie_method_metadata, i) =
                            tpie_method_metadata.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let tpie_method_metadata =
                                match tpie_method_metadata.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            ::quote::ToTokens::to_tokens(&tpie_method_metadata,
                                &mut _s);
                        }
                    }
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! {
606            ($concrete_type:ty, $trait_path:path, $class_system:ident, $no_rd:tt, $internal:tt, $noexport:tt, $no_preconditions:tt) => {
607                ::miniextendr_api::__mx_trait_impl_expand! {
608                    concrete_type = $concrete_type;
609                    trait_path = $trait_path;
610                    class_system = $class_system;
611                    no_rd = $no_rd;
612                    internal = $internal;
613                    noexport = $noexport;
614                    no_preconditions = $no_preconditions;
615                    #abi_metadata
616                    #(#tpie_method_metadata)*
617                }
618            };
619        }
620    } else {
621        ::quote::__private::TokenStream::new();quote::quote! {}
622    };
623    let declaration_generics = &trait_item.generics;
624    let metadata_macro_name = crate::naming::trait_metadata_macro_ident(trait_name);
625    let metadata_macro = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "macro_export");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "hidden");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "macro_rules");
    ::quote::__private::push_bang(&mut _s);
    ::quote::ToTokens::to_tokens(&metadata_macro_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_at(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "impl");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "$");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s, "$");
                                    ::quote::__private::push_ident(&mut _s, "attrs");
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "tt");
                                    _s
                                });
                            ::quote::__private::push_star(&mut _s);
                            _s
                        });
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::parse(&mut _s, "$");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s, "$");
                                    ::quote::__private::push_ident(&mut _s, "implementation");
                                    ::quote::__private::push_colon(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "tt");
                                    _s
                                });
                            ::quote::__private::push_star(&mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_fat_arrow(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "__mx_trait_impl_expand");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_at(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "impl");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s, "$");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s, "$");
                                            ::quote::__private::push_ident(&mut _s, "attrs");
                                            _s
                                        });
                                    ::quote::__private::push_star(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::parse(&mut _s, "$");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::__private::parse(&mut _s, "$");
                                            ::quote::__private::push_ident(&mut _s, "implementation");
                                            _s
                                        });
                                    ::quote::__private::push_star(&mut _s);
                                    _s
                                });
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    {
                                        use ::quote::__private::ext::*;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut method_metadata, i) =
                                            method_metadata.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let method_metadata =
                                                match method_metadata.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            ::quote::ToTokens::to_tokens(&method_metadata, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&declaration_generics,
                                        &mut _s);
                                    _s
                                });
                            ::quote::ToTokens::to_tokens(&abi_metadata, &mut _s);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::ToTokens::to_tokens(&empty_impl_arm, &mut _s);
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "hidden");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "unused_imports");
                    _s
                });
            _s
        });
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "use");
    ::quote::ToTokens::to_tokens(&metadata_macro_name, &mut _s);
    ::quote::__private::push_ident(&mut _s, "as");
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! {
626        #[macro_export]
627        #[doc(hidden)]
628        macro_rules! #metadata_macro_name {
629            (@impl { $($attrs:tt)* } { $($implementation:tt)* }) => {
630                ::miniextendr_api::__mx_trait_impl_expand! {
631                    @impl { $($attrs)* } { $($implementation)* }
632                    { #(#method_metadata)* }
633                    { #declaration_generics }
634                    #abi_metadata
635                }
636            };
637            #empty_impl_arm
638        }
639        #[doc(hidden)]
640        #[allow(unused_imports)]
641        #vis use #metadata_macro_name as #trait_name;
642    };
643
644    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&clean_trait, &mut _s);
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Type tag for runtime identification of the `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"` trait.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&source_loc_doc, &mut _s);
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Generated from source file `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "file");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s,
                        "non_upper_case_globals");
                    _s
                });
            _s
        });
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "const");
    ::quote::ToTokens::to_tokens(&tag_name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "mx_tag");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "mx_tag_from_path");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&tag_path, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "\"Vtable for the `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"` trait.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&source_loc_doc, &mut _s);
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s,
                        "\"Generated from source file `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "file");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Contains one `mx_meth` function pointer per trait method.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "repr");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "C");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "hidden");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s,
                        "non_camel_case_types");
                    _s
                });
            _s
        });
    ::quote::ToTokens::to_tokens(&vis, &mut _s);
    ::quote::__private::push_ident(&mut _s, "struct");
    ::quote::ToTokens::to_tokens(&vtable_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut vtable_fields, i) = vtable_fields.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let vtable_fields =
                        match vtable_fields.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&vtable_fields, &mut _s);
                }
            }
            _s
        });
    ::quote::ToTokens::to_tokens(&view_tokens, &mut _s);
    ::quote::ToTokens::to_tokens(&shim_and_builder, &mut _s);
    ::quote::ToTokens::to_tokens(&metadata_macro, &mut _s);
    _s
}quote::quote! {
645        // Pass through the original trait (with #[miniextendr] attrs stripped from items)
646        #clean_trait
647
648        #[doc = ::core::concat!(
649            "Type tag for runtime identification of the `",
650            ::core::stringify!(#trait_name),
651            "` trait."
652        )]
653        #[doc = #source_loc_doc]
654        #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
655        #[allow(non_upper_case_globals)]
656        #vis const #tag_name: ::miniextendr_api::abi::mx_tag =
657            ::miniextendr_api::abi::mx_tag_from_path(#tag_path);
658
659        #[doc = ::core::concat!("Vtable for the `", ::core::stringify!(#trait_name), "` trait.")]
660        #[doc = #source_loc_doc]
661        #[doc = ::core::concat!("Generated from source file `", ::core::file!(), "`.")]
662        ///
663        /// Contains one `mx_meth` function pointer per trait method.
664        #[repr(C)]
665        #[doc(hidden)]
666        #[allow(non_camel_case_types)]
667        #vis struct #vtable_name {
668            #(#vtable_fields),*
669        }
670
671        #view_tokens
672
673        #shim_and_builder
674
675        #metadata_macro
676    }
677}
678
679/// Encode the exported interface, in vtable order, for `mx_tag_from_path`.
680///
681/// Types use syn's token rendering, not their source whitespace. This is a
682/// syntactic contract: the macro cannot resolve aliases or imported names.
683/// Length-prefix every component so custom R names cannot change its framing.
684fn trait_abi_tag_path(trait_name: &syn::Ident, methods: &[MethodInfo]) -> String {
685    fn push(out: &mut String, component: &str) {
686        use std::fmt::Write;
687        out.write_fmt(format_args!("{0}:{1}", component.len(), component))write!(out, "{}:{component}", component.len()).unwrap();
688    }
689
690    let mut tag = String::from("miniextendr::trait-abi/v2;");
691    push(&mut tag, &crate::naming::ident_name(trait_name));
692    push(&mut tag, &methods.len().to_string());
693    for method in methods {
694        let name = crate::naming::ident_name(&method.name);
695        push(&mut tag, &name);
696        push(&mut tag, method.r_name.as_deref().unwrap_or(&name));
697        push(
698            &mut tag,
699            match method.owner_receiver {
700                Some(crate::trait_receiver::OwnerReceiver::Shared) => "owner-ref",
701                Some(crate::trait_receiver::OwnerReceiver::Mutable) => "owner-mut",
702                None if method.is_mut => "mut",
703                None => "ref",
704            },
705        );
706        push(&mut tag, &method.param_types.len().to_string());
707        for ty in &method.param_types {
708            push(&mut tag, &quote::ToTokens::to_token_stream(ty).to_string());
709        }
710        let result = method
711            .return_type
712            .as_ref()
713            .map(|ty| quote::ToTokens::to_token_stream(ty).to_string())
714            .unwrap_or_else(|| "()".to_owned());
715        push(&mut tag, &result);
716    }
717    tag
718}
719
720/// Generate a method wrapper for the View struct.
721///
722/// This creates a method on the View that calls through the vtable.
723/// Returns None for methods with `Self` in return types or `&Self` in parameters,
724/// since these can't be meaningfully expressed on the type-erased View.
725fn generate_view_method(method: &MethodInfo) -> Option<TokenStream> {
726    // Skip methods where Self appears in return type or parameters.
727    // In the View context, Self refers to the View struct, not the concrete type,
728    // so these methods can't work through the type-erased vtable dispatch.
729    if method.return_type.as_ref().is_some_and(type_contains_self) {
730        return None;
731    }
732    if method.param_types.iter().any(type_contains_self) {
733        return None;
734    }
735
736    let method_name = &method.name;
737    let param_names = &method.param_names;
738    let param_types = &method.param_types;
739
740    // Generate function parameters
741    let params: Vec<_> = param_names
742        .iter()
743        .zip(param_types.iter())
744        .map(|(name, ty)| {
745            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&name, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote::quote! { #name: #ty }
746        })
747        .collect();
748
749    // Generate self receiver
750    let self_param = if method.is_mut {
751        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::__private::push_ident(&mut _s, "self");
    _s
}quote::quote! { &mut self }
752    } else {
753        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_ident(&mut _s, "self");
    _s
}quote::quote! { &self }
754    };
755
756    // Generate argument array for vtable call. A `Missing<T>` argument (an
757    // omittable parameter, e.g. a choice, #1551) crosses as R's
758    // missing-argument sentinel when absent, which the shim's
759    // `TryFromSexp for Missing<T>` reads back; `Missing` has no `IntoR`.
760    let argc = param_types.len() as i32;
761    let arg_conversions: Vec<_> = param_names
762        .iter()
763        .zip(param_types.iter())
764        .map(|(name, ty)| {
765            if crate::miniextendr_fn::get_missing_inner_type(ty).is_some() {
766                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "trait_abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "missing_to_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&name, &mut _s);
            _s
        });
    _s
}quote::quote! {
767                    ::miniextendr_api::trait_abi::missing_to_sexp(#name)
768                }
769            } else {
770                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "trait_abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "to_sexp");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&name, &mut _s);
            _s
        });
    _s
}quote::quote! {
771                    ::miniextendr_api::trait_abi::to_sexp(#name)
772                }
773            }
774        })
775        .collect();
776
777    // Generate vtable call. Each converted argument is rooted before the next
778    // conversion allocates, and stays rooted for the whole call: the shim reads
779    // every `argv` entry back, and SEXP-backed parameters live on in the method
780    // body (the `mx_meth` contract).
781    let owner_argument = method.owner_receiver.map(|_| {
782        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "self");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_view");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "owner");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "expect");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::parse(&mut _s,
                "\"this trait method requires an R-owned receiver\"");
            _s
        });
    ::quote::__private::push_comma(&mut _s);
    _s
}quote::quote! {
783            self.__mx_view.owner().expect("this trait method requires an R-owned receiver"),
784        }
785    });
786    let vtable_call = if argc > 0 {
787        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "args");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_semi(&mut _s);
            ::quote::ToTokens::to_tokens(&argc, &mut _s);
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_ident(&mut _s, "usize");
            _s
        });
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut arg_conversions, i) =
                    arg_conversions.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let arg_conversions =
                        match arg_conversions.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::__private::push_ident(&mut _s, "__mx_roots");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "protect_raw");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&arg_conversions, &mut _s);
                            _s
                        });
                }
            }
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_star(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__mx_view");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vtable");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::ToTokens::to_tokens(&method_name, &mut _s);
            _s
        });
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "self");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "data");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&owner_argument, &mut _s);
            ::quote::ToTokens::to_tokens(&argc, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "args");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "as_ptr");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote::quote! {
788            let args: [::miniextendr_api::SEXP; #argc as usize] =
789                [#(__mx_roots.protect_raw(#arg_conversions)),*];
790            ((*self.__mx_view.vtable()).#method_name)(self.__mx_view.data(), #owner_argument #argc, args.as_ptr())
791        }
792    } else {
793        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_star(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "self");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "__mx_view");
                    ::quote::__private::push_dot(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "vtable");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        ::quote::__private::TokenStream::new());
                    _s
                });
            ::quote::__private::push_dot(&mut _s);
            ::quote::ToTokens::to_tokens(&method_name, &mut _s);
            _s
        });
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "self");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "__mx_view");
            ::quote::__private::push_dot(&mut _s);
            ::quote::__private::push_ident(&mut _s, "data");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&owner_argument, &mut _s);
            ::quote::__private::parse(&mut _s, "0");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ptr");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "null");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote::quote! {
794            ((*self.__mx_view.vtable()).#method_name)(self.__mx_view.data(), #owner_argument 0, ::std::ptr::null())
795        }
796    };
797
798    // Generate return type handling. A returned value is rooted across the
799    // tagged-error check and its conversion back to Rust.
800    let return_type = &method.return_type;
801    let (return_sig, result_binding, result_conversion) = if let Some(ret_ty) = return_type {
802        (
803            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::ToTokens::to_tokens(&ret_ty, &mut _s);
    _s
}quote::quote! { -> #ret_ty },
804            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "__mx_roots");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "protect_raw");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&vtable_call, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! { let result = __mx_roots.protect_raw({ #vtable_call }); },
805            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "trait_abi");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "from_sexp");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ret_ty, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "result");
            _s
        });
    _s
}quote::quote! {
806                ::miniextendr_api::trait_abi::from_sexp::<#ret_ty>(result)
807            },
808        )
809    } else {
810        (
811            ::quote::__private::TokenStream::new()quote::quote! {},
812            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&vtable_call, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! { let result = { #vtable_call }; },
813            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! {
814                let _ = result;
815            },
816        )
817    };
818
819    // The scope owns the argument and result protections; a method with
820    // neither has nothing to root.
821    let roots = if argc > 0 || return_type.is_some() {
822        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "__mx_roots");
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "gc_protect");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ProtectScope");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "new");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! {
823            let __mx_roots = ::miniextendr_api::gc_protect::ProtectScope::new();
824        }
825    } else {
826        ::quote::__private::TokenStream::new();quote::quote! {}
827    };
828
829    // The view keeps the trait's parameter names, so a `_self` parameter (R
830    // formal `self`) sits beside the `self` receiver here too.
831    Some({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "\"Call `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&method_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s,
                        "\"` through the vtable.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "inline");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "clippy");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "duplicate_underscore_argument");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "pub");
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::ToTokens::to_tokens(&method_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&self_param, &mut _s);
            {
                use ::quote::__private::ext::*;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut params, i) = params.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let params =
                        match params.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&params, &mut _s);
                }
            }
            _s
        });
    ::quote::ToTokens::to_tokens(&return_sig, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "unsafe");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&roots, &mut _s);
                    ::quote::ToTokens::to_tokens(&result_binding, &mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "trait_abi");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s,
                        "repanic_if_rust_error");
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_ident(&mut _s, "result");
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&result_conversion, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote::quote! {
832        #[doc = ::core::concat!("Call `", ::core::stringify!(#method_name), "` through the vtable.")]
833        #[inline]
834        #[allow(clippy::duplicate_underscore_argument)]
835        pub fn #method_name(#self_param #(, #params)*) #return_sig {
836            unsafe {
837                #roots
838                #result_binding
839                // Approach 1 (issue #345): if the shim returned a tagged error SEXP,
840                // re-panic with the reconstructed RCondition so the consumer's outer
841                // `with_r_unwind_protect` guard can apply rust_* class layering.
842                ::miniextendr_api::trait_abi::repanic_if_rust_error(result);
843                #result_conversion
844            }
845        }
846    })
847}
848
849/// Generate a method shim function for a trait method.
850///
851/// The shim is an `extern "C"` function that, inside `with_r_unwind_protect_shim`:
852/// 1. Checks argument arity
853/// 2. Refuses aliased native borrows among the arguments
854/// 3. Converts SEXP arguments to Rust types
855/// 4. Calls the actual method on the concrete type
856/// 5. Converts the result back to SEXP
857///
858/// A panic in any step comes back as a tagged condition SEXP, which the View
859/// re-panics with. `generate_concrete_vtable_shims` emits the same steps for
860/// a generic trait's impls.
861///
862/// For generic traits, the shim carries the trait's type parameters plus `__ImplT`.
863fn generate_method_shim(
864    trait_name: &syn::Ident,
865    method: &MethodInfo,
866    extra_bounds: &ExtraBounds,
867    trait_param_idents: &[&syn::Ident],
868    trait_type_params: &[&syn::GenericParam],
869    trait_where_clause: &Option<syn::WhereClause>,
870) -> TokenStream {
871    let method_name = &method.name;
872    let shim_name = crate::naming::trait_method_shim_ident(trait_name, method_name);
873    let impl_t = ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("__ImplT"))
            }), ::quote::__private::Option::None)quote::format_ident!("__ImplT");
874    // User argument bindings keep their source spans. The shim's own
875    // bindings must remain distinct even when a parameter has the same name.
876    let data = syn::Ident::new("data", proc_macro2::Span::mixed_site());
877    let argc = syn::Ident::new("argc", proc_macro2::Span::mixed_site());
878    let argv = syn::Ident::new("argv", proc_macro2::Span::mixed_site());
879    let self_ref = syn::Ident::new("self_ref", proc_macro2::Span::mixed_site());
880    let cell = syn::Ident::new("__mx_cell", proc_macro2::Span::mixed_site());
881    let guard = syn::Ident::new("__mx_guard", proc_macro2::Span::mixed_site());
882    let owner = syn::Ident::new("owner", proc_macro2::Span::mixed_site());
883    let owner_parameter = method.owner_receiver.map(|_| {
884        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&owner, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "SEXP");
    ::quote::__private::push_comma(&mut _s);
    _s
}quote::quote! {
885            #owner: ::miniextendr_api::SEXP,
886        }
887    });
888
889    let param_count = method.param_types.len();
890    let expected_argc = param_count as i32;
891
892    // Generate argument extraction
893    // For &Self params, extract ExternalPtr<__ImplT> and borrow from it
894    let arg_extractions: Vec<_> = method
895        .param_names
896        .iter()
897        .zip(method.param_types.iter())
898        .enumerate()
899        .map(|(i, (name, ty))| {
900            crate::trait_self_ref::argument(
901                name,
902                &crate::naming::ident_name(name),
903                ty,
904                &impl_t,
905                i,
906                &argv,
907                None,
908            )
909        })
910        .collect();
911
912    let native_borrow_checks = crate::trait_self_ref::native_borrow_checks(
913        method
914            .param_names
915            .iter()
916            .zip(&method.param_types)
917            .enumerate()
918            .map(|(index, (name, ty))| (index, crate::naming::ident_name(name), ty)),
919        &argv,
920        None,
921    );
922
923    let self_refs: Vec<_> = method
924        .param_names
925        .iter()
926        .zip(&method.param_types)
927        .enumerate()
928        .filter_map(|(index, (name, ty))| {
929            crate::type_inspect::self_ref_mutability(ty).map(|mutable| (name, mutable, index))
930        })
931        .collect();
932    let handles: Vec<_> = self_refs
933        .iter()
934        .map(|(name, mutable, _)| {
935            (
936                crate::trait_self_ref::handle_ident(name),
937                *mutable,
938                crate::naming::ident_name(name),
939            )
940        })
941        .collect();
942    let alias_checks = crate::trait_self_ref::alias_checks(
943        &impl_t,
944        &handles,
945        Some((crate::trait_self_ref::cell_address(&cell), method.is_mut)),
946    );
947    let self_borrows = self_refs
948        .iter()
949        .map(|(name, mutable, _)| crate::trait_self_ref::borrow(name, *mutable));
950
951    // Generate method call (uses __ImplT). The receiver borrows the value's
952    // RefCell for the rest of the shim, through the result conversion.
953    let param_names = &method.param_names;
954    let (receiver, method_call) = if let Some(kind) = method.owner_receiver {
955        let handle = kind.type_path();
956        let trait_args =
957            (!trait_param_idents.is_empty()).then(|| {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    {
        use ::quote::__private::ext::*;
        let mut _first = true;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut trait_param_idents, i) =
            trait_param_idents.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let trait_param_idents =
                match trait_param_idents.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            if !_first { ::quote::__private::push_comma(&mut _s); }
            _first = false;
            ::quote::ToTokens::to_tokens(&trait_param_idents, &mut _s);
        }
    }
    ::quote::__private::push_gt(&mut _s);
    _s
}quote::quote!(<#(#trait_param_idents),*>));
958        (
959            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&self_ref, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&handle, &mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "from_raw_parts");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_and(&mut _s);
                    ::quote::ToTokens::to_tokens(&owner, &mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&cell, &mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    _s
}quote::quote! {
960                let #self_ref = unsafe {
961                    #handle::<#impl_t>::from_raw_parts(
962                        &#owner,
963                        #cell,
964                    )
965                };
966            },
967            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
    ::quote::__private::push_ident(&mut _s, "as");
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    ::quote::ToTokens::to_tokens(&trait_args, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::ToTokens::to_tokens(&method_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&self_ref, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut param_names, i) = param_names.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let param_names =
                        match param_names.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&param_names, &mut _s);
                }
            }
            _s
        });
    _s
}quote::quote! {
968                <#impl_t as #trait_name #trait_args>::#method_name(#self_ref, #(#param_names),*)
969            },
970        )
971    } else {
972        (
973            crate::trait_self_ref::receiver_borrow(
974                &cell,
975                &guard,
976                &self_ref,
977                method.is_mut,
978                crate::trait_self_ref::ReceiverStorage::Erased,
979            ),
980            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&self_ref, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::ToTokens::to_tokens(&method_name, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            {
                use ::quote::__private::ext::*;
                let mut _first = true;
                let has_iter = ::quote::__private::HasIterator::<false>;
                #[allow(unused_mut)]
                let (mut param_names, i) = param_names.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let param_names =
                        match param_names.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&param_names, &mut _s);
                }
            }
            _s
        });
    _s
}quote::quote! { #self_ref.#method_name(#(#param_names),*) },
981        )
982    };
983
984    // Generate result conversion: a failed `IntoR` is a classed `result_err`
985    // condition (#2272), returned to the View like any other tagged value.
986    let result_conversion = if method.return_type.is_some() {
987        crate::c_wrapper_builder::return_conversion(
988            &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "result");
    _s
}quote::quote!(result),
989            &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "core");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Option");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "None");
    _s
}quote::quote!(::core::option::Option::None),
990        )
991    } else {
992        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_ident(&mut _s, "result");
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "trait_abi");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "nil");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                ::quote::__private::TokenStream::new());
            _s
        });
    _s
}quote::quote! {
993            let _ = result;
994            unsafe { ::miniextendr_api::trait_abi::nil() }
995        }
996    };
997
998    // Build trait bound for __ImplT
999    let trait_bound = if trait_param_idents.is_empty() {
1000        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    _s
}quote::quote! { #trait_name }
1001    } else {
1002        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
    ::quote::__private::push_lt(&mut _s);
    {
        use ::quote::__private::ext::*;
        let mut _first = true;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut trait_param_idents, i) =
            trait_param_idents.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let trait_param_idents =
                match trait_param_idents.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            if !_first { ::quote::__private::push_comma(&mut _s); }
            _first = false;
            ::quote::ToTokens::to_tokens(&trait_param_idents, &mut _s);
        }
    }
    ::quote::__private::push_gt(&mut _s);
    _s
}quote::quote! { #trait_name<#(#trait_param_idents),*> }
1003    };
1004
1005    let impl_bounds = &extra_bounds.impl_bounds;
1006    let all_where_predicates = build_where_predicates(trait_where_clause, extra_bounds);
1007    let where_clause = if all_where_predicates.is_empty() {
1008        ::quote::__private::TokenStream::new();quote::quote! {}
1009    } else {
1010        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "where");
    {
        use ::quote::__private::ext::*;
        let mut _first = true;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut all_where_predicates, i) =
            all_where_predicates.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let all_where_predicates =
                match all_where_predicates.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            if !_first { ::quote::__private::push_comma(&mut _s); }
            _first = false;
            ::quote::ToTokens::to_tokens(&all_where_predicates, &mut _s);
        }
    }
    _s
}quote::quote! { where #(#all_where_predicates),* }
1011    };
1012
1013    let method_name_str = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}::{1}", trait_name,
                method_name))
    })format!("{}::{}", trait_name, method_name);
1014
1015    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "core");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "concat");
            ::quote::__private::push_bang(&mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::parse(&mut _s, "\"Method shim for `\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"::\"");
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "core");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "stringify");
                    ::quote::__private::push_bang(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&method_name, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::__private::parse(&mut _s, "\"`.\"");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s, "r\"\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Converts SEXP arguments, calls the method, and returns SEXP result.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_eq(&mut _s);
            ::quote::__private::parse(&mut _s,
                "r\" Both Rust panics and R longjmps are caught via `with_r_unwind_protect`.\"");
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "doc");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "hidden");
                    _s
                });
            _s
        });
    ::quote::__private::push_pound(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "allow");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "non_snake_case");
                    _s
                });
            _s
        });
    ::quote::__private::push_ident(&mut _s, "unsafe");
    ::quote::__private::push_ident(&mut _s, "extern");
    ::quote::__private::parse(&mut _s, "\"C\"");
    ::quote::__private::push_ident(&mut _s, "fn");
    ::quote::ToTokens::to_tokens(&shim_name, &mut _s);
    ::quote::__private::push_lt(&mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut trait_type_params, i) = trait_type_params.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let trait_type_params =
                match trait_type_params.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&trait_type_params, &mut _s);
            ::quote::__private::push_comma(&mut _s);
        }
    }
    ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::ToTokens::to_tokens(&trait_bound, &mut _s);
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut impl_bounds, i) = impl_bounds.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let impl_bounds =
                match impl_bounds.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::__private::push_add(&mut _s);
            ::quote::ToTokens::to_tokens(&impl_bounds, &mut _s);
        }
    }
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&data, &mut _s);
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_star(&mut _s);
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "os");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "raw");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "c_void");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&owner_parameter, &mut _s);
            ::quote::ToTokens::to_tokens(&argc, &mut _s);
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_ident(&mut _s, "i32");
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&argv, &mut _s);
            ::quote::__private::push_colon(&mut _s);
            ::quote::__private::push_star(&mut _s);
            ::quote::__private::push_ident(&mut _s, "const");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "SEXP");
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    ::quote::__private::push_rarrow(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "SEXP");
    ::quote::ToTokens::to_tokens(&where_clause, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "unwind_protect");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s,
                "with_r_unwind_protect_shim");
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_or_or(&mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "trait_abi");
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "check_arity");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::ToTokens::to_tokens(&argc, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&expected_argc, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::ToTokens::to_tokens(&method_name_str, &mut _s);
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::ToTokens::to_tokens(&cell, &mut _s);
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "unsafe");
                            ::quote::__private::push_group(&mut _s,
                                ::quote::__private::Delimiter::Brace,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_star(&mut _s);
                                    ::quote::ToTokens::to_tokens(&data, &mut _s);
                                    ::quote::__private::push_dot(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "cast");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "core");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "cell");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "RefCell");
                                    ::quote::__private::push_lt(&mut _s);
                                    ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
                                    ::quote::__private::push_shr(&mut _s);
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        ::quote::__private::TokenStream::new());
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::ToTokens::to_tokens(&native_borrow_checks,
                                &mut _s);
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut arg_extractions, i) =
                                    arg_extractions.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let arg_extractions =
                                        match arg_extractions.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&arg_extractions, &mut _s);
                                }
                            }
                            ::quote::ToTokens::to_tokens(&alias_checks, &mut _s);
                            {
                                use ::quote::__private::ext::*;
                                let has_iter = ::quote::__private::HasIterator::<false>;
                                #[allow(unused_mut)]
                                let (mut self_borrows, i) = self_borrows.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let self_borrows =
                                        match self_borrows.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    ::quote::ToTokens::to_tokens(&self_borrows, &mut _s);
                                }
                            }
                            ::quote::ToTokens::to_tokens(&receiver, &mut _s);
                            ::quote::__private::push_ident(&mut _s, "let");
                            ::quote::__private::push_ident(&mut _s, "result");
                            ::quote::__private::push_eq(&mut _s);
                            ::quote::ToTokens::to_tokens(&method_call, &mut _s);
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::ToTokens::to_tokens(&result_conversion, &mut _s);
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote::quote! {
1016        #[doc = ::core::concat!(
1017            "Method shim for `",
1018            ::core::stringify!(#trait_name),
1019            "::",
1020            ::core::stringify!(#method_name),
1021            "`."
1022        )]
1023        ///
1024        /// Converts SEXP arguments, calls the method, and returns SEXP result.
1025        /// Both Rust panics and R longjmps are caught via `with_r_unwind_protect`.
1026        #[doc(hidden)]
1027        #[allow(non_snake_case)]
1028        unsafe extern "C" fn #shim_name<#(#trait_type_params,)* #impl_t: #trait_bound #(+ #impl_bounds)*>(
1029            #data: *mut ::std::os::raw::c_void,
1030            #owner_parameter
1031            #argc: i32,
1032            #argv: *const ::miniextendr_api::SEXP,
1033        ) -> ::miniextendr_api::SEXP
1034        #where_clause
1035        {
1036            // Wrap in with_r_unwind_protect_shim: catches Rust panics and returns
1037            // a tagged error SEXP instead of calling Rf_errorcall directly. The
1038            // tagged SEXP is returned to the View method wrapper which re-panics
1039            // via repanic_if_rust_error, allowing the consumer's outer
1040            // `with_r_unwind_protect` guard to produce rust_* class layering
1041            // (issue #345). R-origin longjmps still propagate via R_ContinueUnwind.
1042            ::miniextendr_api::unwind_protect::with_r_unwind_protect_shim(|| {
1043                ::miniextendr_api::trait_abi::check_arity(#argc, #expected_argc, #method_name_str);
1044                let #cell = unsafe { &*#data.cast::<::core::cell::RefCell<#impl_t>>() };
1045                #native_borrow_checks
1046                // Extract arguments
1047                #(#arg_extractions)*
1048                #alias_checks
1049                #(#self_borrows)*
1050
1051                // Call method
1052                #receiver
1053                let result = #method_call;
1054
1055                // Convert result
1056                #result_conversion
1057            })
1058        }
1059    }
1060}
1061
1062/// Move the declaration shim into the trait so an impl can name it through
1063/// any path to that trait. `Self: Sized` keeps these static ABI callbacks out
1064/// of Rust trait objects. Types in the body still resolve at the declaration.
1065fn associated_method_shim(tokens: TokenStream) -> syn::TraitItemFn {
1066    use syn::visit_mut::VisitMut;
1067
1068    struct ImplTypeToSelf;
1069    impl VisitMut for ImplTypeToSelf {
1070        fn visit_path_mut(&mut self, path: &mut syn::Path) {
1071            syn::visit_mut::visit_path_mut(self, path);
1072            if let Some(first) = path.segments.first_mut()
1073                && first.ident == "__ImplT"
1074            {
1075                first.ident = syn::Ident::new("Self", first.ident.span());
1076            }
1077        }
1078    }
1079
1080    let mut shim: syn::TraitItemFn = syn::parse2(tokens).expect("generated method shim");
1081    let syn::GenericParam::Type(implementation) =
1082        shim.sig.generics.params.pop().unwrap().into_value()
1083    else {
1084        {
    ::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}",
            format_args!("the final generated parameter is __ImplT")));
}unreachable!("the final generated parameter is __ImplT")
1085    };
1086    let bounds = implementation.bounds;
1087    shim.sig
1088        .generics
1089        .make_where_clause()
1090        .predicates
1091        .push(::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_ident(&mut _s, "Self");
        ::quote::__private::push_colon(&mut _s);
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "core");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "marker");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Sized");
        ::quote::__private::push_add(&mut _s);
        ::quote::ToTokens::to_tokens(&bounds, &mut _s);
        _s
    })syn::parse_quote!(Self: ::core::marker::Sized + #bounds));
1092    ImplTypeToSelf.visit_trait_item_fn_mut(&mut shim);
1093    shim
1094}
1095
1096/// Information extracted from a trait method for code generation.
1097///
1098/// Collects everything needed to generate vtable shims, view methods,
1099/// and extra trait bounds for a single method in a `#[miniextendr]` trait.
1100#[derive(#[automatically_derived]impl ::core::fmt::Debug for MethodInfo {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        let names: &'static _ =
            "MethodInfo name has_self is_mut owner_receiver param_types param_names return_type skip r_name";
        let values: &[&dyn ::core::fmt::Debug] =
            &[&self.name, &self.has_self, &self.is_mut, &self.owner_receiver,
                        &self.param_types, &self.param_names, &self.return_type,
                        &self.skip, &&self.r_name];
        ::core::fmt::Formatter::debug_struct_fields_finish(f, names, values)
    }
}Debug)]
1101struct MethodInfo {
1102    /// Method name (Rust identifier).
1103    name: syn::Ident,
1104    /// Whether the method has a self receiver (instance method).
1105    /// False for static/associated methods.
1106    has_self: bool,
1107    /// Whether receiver is `&mut self` (vs `&self`). Only meaningful if `has_self` is true.
1108    is_mut: bool,
1109    owner_receiver: Option<crate::trait_receiver::OwnerReceiver>,
1110    /// Parameter types (excluding the self receiver).
1111    param_types: Vec<syn::Type>,
1112    /// Parameter names (excluding the self receiver). Uses `arg{i}` for unnamed patterns.
1113    param_names: Vec<syn::Ident>,
1114    /// Return type. `None` when the method returns `()` (unit type or no return annotation).
1115    return_type: Option<syn::Type>,
1116    /// Whether method is marked `#[miniextendr(skip)]`, excluding it from codegen.
1117    skip: bool,
1118    /// Override the R-facing method name (from `#[miniextendr(r_name = "...")]`).
1119    /// When set, R wrappers and TPIE metadata use this name instead of the Rust ident.
1120    r_name: Option<String>,
1121}
1122
1123// region: Self-type detection helpers
1124
1125/// Check if a type syntactically contains `Self`.
1126///
1127/// Used to detect when a method returns `Self` (or `Option<Self>`, `Vec<Self>`, etc.)
1128/// so the generated shim can add `IntoR` bounds.
1129fn type_contains_self(ty: &syn::Type) -> bool {
1130    match ty {
1131        syn::Type::Path(tp) => {
1132            for seg in &tp.path.segments {
1133                if seg.ident == "Self" {
1134                    return true;
1135                }
1136                if let syn::PathArguments::AngleBracketed(args) = &seg.arguments {
1137                    for arg in &args.args {
1138                        if let syn::GenericArgument::Type(inner) = arg
1139                            && type_contains_self(inner)
1140                        {
1141                            return true;
1142                        }
1143                    }
1144                }
1145            }
1146            false
1147        }
1148        syn::Type::Reference(r) => type_contains_self(&r.elem),
1149        syn::Type::Tuple(t) => t.elems.iter().any(type_contains_self),
1150        syn::Type::Slice(s) => type_contains_self(&s.elem),
1151        syn::Type::Array(a) => type_contains_self(&a.elem),
1152        syn::Type::Paren(p) => type_contains_self(&p.elem),
1153        _ => false,
1154    }
1155}
1156
1157/// Check if a type syntactically contains `Self::AssocType` for a given associated type name.
1158///
1159/// Recursively walks the type tree looking for a 2-segment path where the first
1160/// segment is `Self` and the second matches `assoc_name` (e.g., `Self::Item`).
1161/// Used to determine whether extra `where` bounds are needed for associated types.
1162fn type_contains_self_assoc(ty: &syn::Type, assoc_name: &syn::Ident) -> bool {
1163    match ty {
1164        syn::Type::Path(tp) => {
1165            if tp.path.segments.len() == 2
1166                && tp.path.segments[0].ident == "Self"
1167                && tp.path.segments[1].ident == *assoc_name
1168            {
1169                return true;
1170            }
1171            for seg in &tp.path.segments {
1172                if let syn::PathArguments::AngleBracketed(args) = &seg.arguments {
1173                    for arg in &args.args {
1174                        if let syn::GenericArgument::Type(inner) = arg
1175                            && type_contains_self_assoc(inner, assoc_name)
1176                        {
1177                            return true;
1178                        }
1179                    }
1180                }
1181            }
1182            false
1183        }
1184        syn::Type::Reference(r) => type_contains_self_assoc(&r.elem, assoc_name),
1185        syn::Type::Tuple(t) => t
1186            .elems
1187            .iter()
1188            .any(|e| type_contains_self_assoc(e, assoc_name)),
1189        syn::Type::Slice(s) => type_contains_self_assoc(&s.elem, assoc_name),
1190        syn::Type::Array(a) => type_contains_self_assoc(&a.elem, assoc_name),
1191        syn::Type::Paren(p) => type_contains_self_assoc(&p.elem, assoc_name),
1192        _ => false,
1193    }
1194}
1195
1196/// Rewrite `Self` and `Self::AssocType` in a type tree to use `__ImplT`.
1197///
1198/// Transforms:
1199/// - `Self` → `__ImplT`
1200/// - `Self::Item` → `<__ImplT as TraitName>::Item`
1201/// - Recursively processes generic arguments (e.g., `Option<Self::Item>` →
1202///   `Option<<__ImplT as TraitName>::Item>`)
1203fn rewrite_self_in_type(
1204    ty: &syn::Type,
1205    trait_name: &syn::Ident,
1206    assoc_types: &[&syn::Ident],
1207) -> syn::Type {
1208    match ty {
1209        syn::Type::Path(tp) => {
1210            // Check for Self::AssocType (2-segment path: Self::Item)
1211            if tp.path.segments.len() == 2
1212                && tp.path.segments[0].ident == "Self"
1213                && assoc_types.iter().any(|a| *a == &tp.path.segments[1].ident)
1214            {
1215                let assoc = &tp.path.segments[1].ident;
1216                let impl_t = ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("__ImplT"))
            }), ::quote::__private::Option::None)quote::format_ident!("__ImplT");
1217                return ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
        ::quote::__private::push_ident(&mut _s, "as");
        ::quote::ToTokens::to_tokens(&trait_name, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        ::quote::__private::push_colon2(&mut _s);
        ::quote::ToTokens::to_tokens(&assoc, &mut _s);
        _s
    })syn::parse_quote!(<#impl_t as #trait_name>::#assoc);
1218            }
1219            // Check for bare Self
1220            if tp.path.is_ident("Self") {
1221                let impl_t = ::quote::__private::mk_ident(&::alloc::__export::must_use({
                ::alloc::fmt::format(format_args!("__ImplT"))
            }), ::quote::__private::Option::None)quote::format_ident!("__ImplT");
1222                return ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::ToTokens::to_tokens(&impl_t, &mut _s);
        _s
    })syn::parse_quote!(#impl_t);
1223            }
1224            // Recursively process generic args
1225            let mut new_tp = tp.clone();
1226            for seg in &mut new_tp.path.segments {
1227                if let syn::PathArguments::AngleBracketed(args) = &mut seg.arguments {
1228                    for arg in &mut args.args {
1229                        if let syn::GenericArgument::Type(inner) = arg {
1230                            *inner = rewrite_self_in_type(inner, trait_name, assoc_types);
1231                        }
1232                    }
1233                }
1234            }
1235            syn::Type::Path(new_tp)
1236        }
1237        syn::Type::Reference(r) => {
1238            let mut new_r = r.clone();
1239            new_r.elem = Box::new(rewrite_self_in_type(&r.elem, trait_name, assoc_types));
1240            syn::Type::Reference(new_r)
1241        }
1242        syn::Type::Tuple(t) => {
1243            let mut new_t = t.clone();
1244            for elem in &mut new_t.elems {
1245                *elem = rewrite_self_in_type(elem, trait_name, assoc_types);
1246            }
1247            syn::Type::Tuple(new_t)
1248        }
1249        syn::Type::Slice(s) => {
1250            let mut new_s = s.clone();
1251            new_s.elem = Box::new(rewrite_self_in_type(&s.elem, trait_name, assoc_types));
1252            syn::Type::Slice(new_s)
1253        }
1254        syn::Type::Array(a) => {
1255            let mut new_a = a.clone();
1256            new_a.elem = Box::new(rewrite_self_in_type(&a.elem, trait_name, assoc_types));
1257            syn::Type::Array(new_a)
1258        }
1259        syn::Type::Paren(p) => {
1260            let mut new_p = p.clone();
1261            new_p.elem = Box::new(rewrite_self_in_type(&p.elem, trait_name, assoc_types));
1262            syn::Type::Paren(new_p)
1263        }
1264        _ => ty.clone(),
1265    }
1266}
1267
1268/// Check if a type syntactically contains a specific identifier.
1269///
1270/// Used to detect trait type parameters (like `T`) in method signatures so that
1271/// appropriate `TryFromSexp` or `IntoR` bounds can be added. Recursively walks
1272/// through path segments, generic arguments, references, tuples, slices, and arrays.
1273fn type_contains_ident(ty: &syn::Type, ident: &syn::Ident) -> bool {
1274    match ty {
1275        syn::Type::Path(tp) => {
1276            if tp.path.segments.len() == 1 && tp.path.segments[0].ident == *ident {
1277                return true;
1278            }
1279            for seg in &tp.path.segments {
1280                if let syn::PathArguments::AngleBracketed(args) = &seg.arguments {
1281                    for arg in &args.args {
1282                        if let syn::GenericArgument::Type(inner) = arg
1283                            && type_contains_ident(inner, ident)
1284                        {
1285                            return true;
1286                        }
1287                    }
1288                }
1289            }
1290            false
1291        }
1292        syn::Type::Reference(r) => type_contains_ident(&r.elem, ident),
1293        syn::Type::Tuple(t) => t.elems.iter().any(|e| type_contains_ident(e, ident)),
1294        syn::Type::Slice(s) => type_contains_ident(&s.elem, ident),
1295        syn::Type::Array(a) => type_contains_ident(&a.elem, ident),
1296        syn::Type::Paren(p) => type_contains_ident(&p.elem, ident),
1297        _ => false,
1298    }
1299}
1300
1301/// Extra trait bounds inferred from method signatures.
1302///
1303/// For generic traits and methods that reference `Self` or associated types,
1304/// the generated shim and vtable builder functions need additional bounds
1305/// beyond `__ImplT: TraitName`. This struct collects those bounds.
1306struct ExtraBounds {
1307    /// Bounds added directly to `__ImplT` (e.g., `IntoR` when methods return `Self`,
1308    /// or `TypedExternal + 'static` when methods take `&Self` parameters).
1309    impl_bounds: Vec<TokenStream>,
1310    /// Where clause predicates for complex types (e.g.,
1311    /// `<__ImplT as Trait>::Item: IntoR` or `Vec<T>: TryFromSexp`).
1312    where_predicates: Vec<TokenStream>,
1313}
1314
1315/// Compute extra bounds needed for the shim and build_vtable functions.
1316///
1317/// - Methods returning `Self` → `__ImplT: IntoR`
1318/// - Methods with `&Self` params → `__ImplT: TypedExternal + 'static`
1319/// - Methods returning types with `Self::AssocType` or trait type params →
1320///   full rewritten return type `: IntoR` (e.g., `Nullable<<__ImplT as RIterator>::Item>: IntoR`)
1321/// - Methods with trait type params in params →
1322///   full param type `: TryFromSexp` (e.g., `Vec<T>: TryFromSexp`)
1323fn compute_extra_bounds(
1324    methods: &[MethodInfo],
1325    trait_name: &syn::Ident,
1326    assoc_types: &[&syn::Ident],
1327    trait_param_idents: &[&syn::Ident],
1328) -> ExtraBounds {
1329    let mut impl_bounds = Vec::new();
1330    let mut where_predicates = Vec::new();
1331
1332    let mut needs_into_r = false;
1333    let mut needs_typed_external = false;
1334    let needs_owner = methods.iter().any(|method| method.owner_receiver.is_some());
1335
1336    // Track full types needing bounds (deduplicated by token string)
1337    let mut return_type_bound_keys: std::collections::BTreeMap<String, syn::Type> =
1338        Default::default();
1339    let mut param_type_bound_keys: std::collections::BTreeMap<String, syn::Type> =
1340        Default::default();
1341
1342    for method in methods {
1343        // Bare Self in returns → __ImplT: IntoR (as impl bound)
1344        if method.return_type.as_ref().is_some_and(type_contains_self) {
1345            needs_into_r = true;
1346        }
1347        // &Self in params → __ImplT: TypedExternal + 'static
1348        if method
1349            .param_types
1350            .iter()
1351            .any(|ty| crate::type_inspect::self_ref_mutability(ty).is_some())
1352        {
1353            needs_typed_external = true;
1354        }
1355
1356        // Full return type bounds for Self::AssocType and/or trait type params.
1357        // Instead of bare `<__ImplT as Trait>::Item: IntoR`, we add the FULL rewritten
1358        // return type: `Option<<__ImplT as Trait>::Item>: IntoR`, `Vec<T>: IntoR`, etc.
1359        // This is required because IntoR impls are concrete (no blanket `Option<T: IntoR>: IntoR`).
1360        if let Some(ref ret_ty) = method.return_type {
1361            let has_assoc = assoc_types
1362                .iter()
1363                .any(|a| type_contains_self_assoc(ret_ty, a));
1364            let has_param = trait_param_idents
1365                .iter()
1366                .any(|p| type_contains_ident(ret_ty, p));
1367            if has_assoc || has_param {
1368                let rewritten = rewrite_self_in_type(ret_ty, trait_name, assoc_types);
1369                let key = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&rewritten, &mut _s);
    _s
}quote::quote!(#rewritten).to_string();
1370                return_type_bound_keys.entry(key).or_insert(rewritten);
1371            }
1372        }
1373
1374        // Full param type bounds for trait type params.
1375        // Instead of bare `T: TryFromSexp`, we add `Vec<T>: TryFromSexp` etc.
1376        for param_ty in &method.param_types {
1377            if crate::type_inspect::self_ref_mutability(param_ty).is_none() {
1378                let has_param = trait_param_idents
1379                    .iter()
1380                    .any(|p| type_contains_ident(param_ty, p));
1381                if has_param {
1382                    let key = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&param_ty, &mut _s);
    _s
}quote::quote!(#param_ty).to_string();
1383                    param_type_bound_keys.entry(key).or_insert(param_ty.clone());
1384                }
1385            }
1386        }
1387    }
1388
1389    if needs_into_r {
1390        impl_bounds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoR");
    _s
}quote::quote! { ::miniextendr_api::IntoR });
1391    }
1392    if needs_typed_external {
1393        impl_bounds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "TypedExternal");
    ::quote::__private::push_add(&mut _s);
    ::quote::__private::push_lifetime(&mut _s, "\'static");
    _s
}quote::quote! { ::miniextendr_api::TypedExternal + 'static });
1394    }
1395
1396    if needs_owner && !needs_typed_external {
1397        impl_bounds.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "TypedExternal");
    _s
}quote::quote! { ::miniextendr_api::TypedExternal });
1398    }
1399
1400    // Add full return type bounds: RewrittenType: IntoR
1401    for ty in return_type_bound_keys.values() {
1402        where_predicates.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "IntoR");
    _s
}quote::quote! {
1403            #ty: ::miniextendr_api::IntoR
1404        });
1405    }
1406
1407    // Add full param type bounds: ParamType: TryFromSexp, Error: Display
1408    for ty in param_type_bound_keys.values() {
1409        where_predicates.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
    _s
}quote::quote! {
1410            #ty: ::miniextendr_api::TryFromSexp
1411        });
1412        where_predicates.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_ident(&mut _s, "as");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "TryFromSexp");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Error");
    ::quote::__private::push_colon(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "std");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "fmt");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Display");
    _s
}quote::quote! {
1413            <#ty as ::miniextendr_api::TryFromSexp>::Error: ::std::fmt::Display
1414        });
1415    }
1416
1417    ExtraBounds {
1418        impl_bounds,
1419        where_predicates,
1420    }
1421}
1422
1423/// Build combined where predicates from the trait's own where clause and computed extra bounds.
1424///
1425/// Merges the original trait-level where clause predicates with the extra
1426/// bounds computed from method signatures (e.g., `IntoR` for return types,
1427/// `TryFromSexp` for parameters containing trait type params).
1428///
1429/// Returns a flat list of predicates suitable for use in a `where` clause.
1430fn build_where_predicates(
1431    trait_where_clause: &Option<syn::WhereClause>,
1432    extra_bounds: &ExtraBounds,
1433) -> Vec<TokenStream> {
1434    let mut all = Vec::new();
1435    if let Some(wc) = trait_where_clause {
1436        for pred in &wc.predicates {
1437            all.push({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&pred, &mut _s);
    _s
}quote::quote! { #pred });
1438        }
1439    }
1440    all.extend(extra_bounds.where_predicates.iter().cloned());
1441    all
1442}
1443
1444/// Extract method information from a trait method definition.
1445///
1446/// Parses the method signature to determine receiver type, parameter names/types,
1447/// return type, and any `#[miniextendr(...)]` attributes like `skip` and `r_name`.
1448/// Parameters with non-ident patterns are assigned synthetic names (`arg0`, `arg1`, etc.).
1449fn extract_method_info(method: &syn::TraitItemFn) -> syn::Result<MethodInfo> {
1450    let name = method.sig.ident.clone();
1451
1452    // Check for #[miniextendr(skip)] and #[miniextendr(r_name = "...")]
1453    let mut skip = false;
1454    let mut r_name: Option<String> = None;
1455    for attr in &method.attrs {
1456        if !attr.path().is_ident("miniextendr") {
1457            continue;
1458        }
1459        attr.parse_nested_meta(|meta| {
1460            if meta.path.is_ident("skip") {
1461                skip = true;
1462            } else if meta.path.is_ident("r_name") {
1463                let value: syn::LitStr = meta.value()?.parse()?;
1464                r_name = Some(value.value());
1465            } else if meta.path.is_ident("formal") {
1466                return Err(meta.error(crate::miniextendr_fn::TRAIT_FORMAL_UNSUPPORTED));
1467            } else {
1468                return Err(meta.error(
1469                    "unknown #[miniextendr] option on trait method; expected `skip` or `r_name`",
1470                ));
1471            }
1472            Ok(())
1473        })?;
1474    }
1475
1476    if !skip {
1477        crate::miniextendr_fn::require_safe_wrapper(&method.sig, "mark it `#[miniextendr(skip)]`")?;
1478    }
1479
1480    // Check for receiver
1481    let (has_self, is_mut) = method.sig.inputs.first().map_or((false, false), |arg| {
1482        if let syn::FnArg::Receiver(_) = arg {
1483            (true, crate::trait_receiver::is_mut(&method.sig))
1484        } else {
1485            (false, false)
1486        }
1487    });
1488
1489    // Extract parameters (skip self if present)
1490    let skip_count = if has_self { 1 } else { 0 };
1491    let mut param_types = Vec::new();
1492    let mut param_names = Vec::new();
1493    for (i, arg) in method.sig.inputs.iter().skip(skip_count).enumerate() {
1494        if let syn::FnArg::Typed(pat_type) = arg {
1495            if crate::return_wrap::contains_marker(&pat_type.ty) {
1496                return Err(syn::Error::new_spanned(
1497                    &pat_type.ty,
1498                    "class return markers are return-position only",
1499                ));
1500            }
1501            // `Checked<T>` / `Unchecked<T>` (#1566) steer an R wrapper's type
1502            // checks and `NonNa<T>` its `no_na` check, and a trait's View
1503            // passes arguments on as R values: the wrappers belong to each
1504            // impl, which says it there.
1505            let (markers, _) = crate::type_inspect::peel_param_markers(&pat_type.ty)?;
1506            if let Some(marker) = markers.first() {
1507                let name = match pat_type.pat.as_ref() {
1508                    syn::Pat::Ident(pat_ident) => crate::naming::ident_name(&pat_ident.ident),
1509                    _ => "x".to_string(),
1510                };
1511                return Err(syn::Error::new_spanned(
1512                    &pat_type.ty,
1513                    ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("`{0}<T>` in a `#[miniextendr]` trait method: the trait\'s View passes arguments on as R values, and each impl\'s wrapper checks them; spell it on the impl, `#[miniextendr({1})]`",
                marker.name(), marker.impl_keyword(&name)))
    })format!(
1514                        "`{}<T>` in a `#[miniextendr]` trait method: the trait's View passes \
1515                         arguments on as R values, and each impl's wrapper checks them; spell it \
1516                         on the impl, `#[miniextendr({})]`",
1517                        marker.name(),
1518                        marker.impl_keyword(&name),
1519                    ),
1520                ));
1521            }
1522            param_types.push((*pat_type.ty).clone());
1523            if let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() {
1524                param_names.push(pat_ident.ident.clone());
1525            } else {
1526                param_names.push(match ::quote::__private::IdentFragmentAdapter(&i) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("arg{0}", arg))
                    }), ::quote::__private::Option::None.or(arg.span())),
}quote::format_ident!("arg{}", i));
1527            }
1528        }
1529    }
1530
1531    // Extract return type. A visibility marker (`Invisible<T>` / `Visible<T>`,
1532    // #1213) only steers the implementing package's R wrapper; the View and
1533    // the vtable bounds work on the inner type.
1534    let return_type = match &method.sig.output {
1535        syn::ReturnType::Default => None,
1536        syn::ReturnType::Type(_, ty) => {
1537            if let Some(err) = crate::type_inspect::visibility_marker_error(ty, "return") {
1538                return Err(err);
1539            }
1540            let (_, ty) = crate::type_inspect::peel_visibility_marker(ty);
1541            let output: syn::ReturnType = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_rarrow(&mut _s);
        ::quote::ToTokens::to_tokens(&ty, &mut _s);
        _s
    })syn::parse_quote!(-> #ty);
1542            let (wrap, output) = crate::return_wrap::resolve(&output, None)?;
1543            if wrap.as_ref().is_some_and(|wrap| wrap.conversion.is_some()) {
1544                return Err(syn::Error::new_spanned(
1545                    ty,
1546                    "ConvertTo/ConvertFrom require an inherent S7 impl method",
1547                ));
1548            }
1549            let syn::ReturnType::Type(_, ty) = output else {
1550                ::core::panicking::unreachable_default_msg()unreachable!()
1551            };
1552            let ty = ty.as_ref();
1553            // Check if it's unit type ()
1554            if #[allow(non_exhaustive_omitted_patterns)] match ty {
    syn::Type::Tuple(t) if t.elems.is_empty() => true,
    _ => false,
}matches!(ty, syn::Type::Tuple(t) if t.elems.is_empty()) {
1555                None
1556            } else {
1557                Some(ty.clone())
1558            }
1559        }
1560    };
1561
1562    Ok(MethodInfo {
1563        name,
1564        has_self,
1565        is_mut,
1566        owner_receiver: crate::trait_receiver::owner_receiver(&method.sig),
1567        param_types,
1568        param_names,
1569        return_type,
1570        skip,
1571        r_name,
1572    })
1573}
1574
1575#[cfg(test)]
1576mod tests;
1577// endregion